desktop/src/MigrateDlg.cc

   1 ///
   2 /// \file       MigrateDlg.cc
   3 ///             Dialog for the "Migrate Device" main menu mode button...
   4 ///             going with a dialog instead of a mode class this time.
   5 ///
   6
   7 /*
   8     Copyright (C) 2012, Net Direct Inc. (http://www.netdirect.ca/)
   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 "MigrateDlg.h"
  24 #include "windowids.h"
  25 #include "configui.h"
  26 #include "barrydesktop.h"
  27 #include <string>
  28 #include <wx/statline.h>
  29 #include <barry/barrybackup.h>
  30 #include <iostream>
  31
  32 using namespace std;
  33 using namespace OpenSync;
  34
  35 DEFINE_EVENT_TYPE(MET_THREAD_FINISHED)
  36 DEFINE_EVENT_TYPE(MET_CHECK_DEST_PIN)
  37 DEFINE_EVENT_TYPE(MET_SET_STATUS_MSG)
  38 DEFINE_EVENT_TYPE(MET_PROMPT_PASSWORD)
  39 DEFINE_EVENT_TYPE(MET_ERROR_MSG)
  40
  41 BEGIN_EVENT_TABLE(MigrateDlg, wxDialog)
  42         EVT_BUTTON      (Dialog_Migrate_MigrateNowButton,
  43                                 MigrateDlg::OnMigrateNow)
  44         EVT_BUTTON      (Dialog_Migrate_CancelButton,
  45                                 MigrateDlg::OnCancel)
  46         EVT_CLOSE       (MigrateDlg::OnCloseWindow)
  47         EVT_COMMAND     (wxID_ANY, MET_THREAD_FINISHED,
  48                                 MigrateDlg::OnThreadFinished)
  49         EVT_COMMAND     (wxID_ANY, MET_CHECK_DEST_PIN,
  50                                 MigrateDlg::OnCheckDestPin)
  51         EVT_COMMAND     (wxID_ANY, MET_SET_STATUS_MSG,
  52                                 MigrateDlg::OnSetStatusMsg)
  53         EVT_COMMAND     (wxID_ANY, MET_PROMPT_PASSWORD,
  54                                 MigrateDlg::OnPromptPassword)
  55         EVT_COMMAND     (wxID_ANY, MET_ERROR_MSG,
  56                                 MigrateDlg::OnErrorMsg)
  57 END_EVENT_TABLE()
  58
  59
  60 class EventDesktopConnector : public Barry::DesktopConnector
  61 {
  62         MigrateDlg *m_dlg;
  63
  64 public:
  65         EventDesktopConnector(MigrateDlg *dlg, const char *password,
  66                 const std::string &locale, const Barry::ProbeResult &result)
  67                 : Barry::DesktopConnector(password, locale, result)
  68                 , m_dlg(dlg)
  69         {
  70         }
  71
  72         virtual bool PasswordPrompt(const Barry::BadPassword &bp,
  73                                         std::string &password_result);
  74 };
  75
  76 bool EventDesktopConnector::PasswordPrompt(const Barry::BadPassword &bp,
  77                                         std::string &password_result)
  78 {
  79         // ping the parent and wait for finish
  80         wxCommandEvent event(MET_PROMPT_PASSWORD, wxID_ANY);
  81         event.SetEventObject(m_dlg);
  82         event.SetInt(bp.remaining_tries());
  83         m_dlg->AddPendingEvent(event);
  84         m_dlg->WaitForEvent();
  85
  86         password_result = m_dlg->GetPassword().utf8_str();
  87
  88         // assume that a blank password means the user wishes to quit...
  89         // wxWidgets doesn't seem to handle this very well?
  90         return password_result.size() > 0;
  91 }
  92
  93
  94 //////////////////////////////////////////////////////////////////////////////
  95 // MigrateDlg class
  96
  97 MigrateDlg::MigrateDlg(wxWindow *parent,
  98                         const Barry::Probe::Results &results,
  99                         int current_device_index)
 100         : wxDialog(parent, Dialog_GroupCfg, _T("Migrate Device"))
 101         , m_results(results)
 102         , m_current_device_index(current_device_index)
 103         , m_migrate_thread_created(false)
 104         , m_abort_flag(false)
 105         , m_thread_running(false)
 106         , m_source_device(0)
 107         , m_dest_device(0)
 108         , m_topsizer(0)
 109         , m_source_combo(0)
 110         , m_dest_combo(0)
 111         , m_write_mode_combo(0)
 112         , m_migrate_button(0)
 113         , m_wipe_check(0)
 114         , m_status(0)
 115         , m_progress(0)
 116 {
 117         // setup the raw GUI
 118         CreateLayout();
 119 }
 120
 121 void MigrateDlg::WaitForEvent()
 122 {
 123         m_waiter.Wait();
 124 }
 125
 126 void MigrateDlg::CreateLayout()
 127 {
 128         m_topsizer = new wxBoxSizer(wxVERTICAL);
 129
 130 //      AddDescriptionSizer(m_topsizer);
 131         AddMainSizer(m_topsizer);
 132         AddStatusSizer(m_topsizer);
 133
 134         SetSizer(m_topsizer);
 135         m_topsizer->SetSizeHints(this);
 136         m_topsizer->Layout();
 137 }
 138
 139 void MigrateDlg::AddDescriptionSizer(wxSizer *sizer)
 140 {
 141         sizer->Add(
 142                 new wxStaticText(this, wxID_ANY,
 143                         _T("Migrate device data from source device to target device.")),
 144                 0, wxALIGN_CENTRE | wxALIGN_CENTRE_VERTICAL |
 145                         wxTOP | wxLEFT | wxRIGHT, 10);
 146 }
 147
 148 void MigrateDlg::AddMainSizer(wxSizer *sizer)
 149 {
 150         // add 3 main sections together into one sizer
 151         wxSizer *main = new wxBoxSizer(wxHORIZONTAL);
 152         Main_AddSourceSizer(main);
 153         Main_AddButtonSizer(main);
 154         Main_AddDestSizer(main);
 155
 156         // add main sizer to top level sizer
 157         sizer->Add(main, 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, 10);
 158 }
 159
 160 void MigrateDlg::AddStatusSizer(wxSizer *sizer)
 161 {
 162         sizer->Add( new wxStaticLine(this),
 163                 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, 10);
 164
 165         sizer->Add(
 166                 m_status = new wxStaticText(this, wxID_ANY, _T("Ready...")),
 167                 0, wxEXPAND | wxLEFT | wxRIGHT, 10);
 168         // Reduce font size for status text
 169         wxFont font = m_status->GetFont();
 170         font.SetPointSize(font.GetPointSize() - 1);
 171         m_status->SetFont( font );
 172
 173         sizer->Add(
 174                 m_progress = new wxGauge(this, wxID_ANY, 100),
 175                 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 10);
 176 }
 177
 178 void MigrateDlg::Main_AddSourceSizer(wxSizer *sizer)
 179 {
 180         wxArrayString devices;
 181         for( Barry::Probe::Results::const_iterator i = m_results.begin();
 182                                 i != m_results.end(); ++i )
 183         {
 184                 devices.Add(wxString(i->GetDisplayName().c_str(), wxConvUTF8));
 185         }
 186
 187         wxSizer *source = new wxStaticBoxSizer(
 188                 new wxStaticBox(this, wxID_ANY, _T("Source device")),
 189                 wxVERTICAL
 190                 );
 191         source->Add(
 192                 m_source_combo = new wxChoice(this, wxID_ANY,
 193                         wxDefaultPosition, wxSize(225, -1), devices),
 194                 0, wxALL, 5);
 195
 196         if( m_current_device_index >= 0 )
 197                 m_source_combo->SetSelection(m_current_device_index);
 198
 199         sizer->Add(source, 0, wxEXPAND, 0);
 200 }
 201
 202 void MigrateDlg::Main_AddButtonSizer(wxSizer *sizer)
 203 {
 204         wxSizer *buttons = new wxBoxSizer(wxVERTICAL);
 205         buttons->Add( m_migrate_button = new wxButton(this,
 206                 Dialog_Migrate_MigrateNowButton, _T("Migrate Now")),
 207                 0, wxALIGN_CENTRE, 0);
 208         m_migrate_button->SetDefault();
 209         buttons->AddSpacer(10);
 210         buttons->Add( new wxButton(this, Dialog_Migrate_CancelButton,
 211                         _T("Cancel")),
 212                 0, wxALIGN_CENTRE, 0);
 213
 214         sizer->Add(buttons, 1, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 10);
 215 }
 216
 217 void MigrateDlg::Main_AddDestSizer(wxSizer *sizer)
 218 {
 219         wxArrayString devices;
 220         devices.Add(_T("Prompt to plug in later..."));
 221         for( Barry::Probe::Results::const_iterator i = m_results.begin();
 222                                 i != m_results.end(); ++i )
 223         {
 224                 devices.Add(wxString(i->GetDisplayName().c_str(), wxConvUTF8));
 225         }
 226
 227         wxSizer *dest = new wxStaticBoxSizer(
 228                 new wxStaticBox(this, wxID_ANY, _T("Destination device")),
 229                 wxVERTICAL
 230                 );
 231         dest->Add(
 232                 m_dest_combo = new wxChoice(this, wxID_ANY,
 233                         wxDefaultPosition, wxSize(225, -1), devices),
 234                 0, wxALL, 5);
 235         m_dest_combo->SetSelection(0);
 236
 237
 238         wxArrayString write_modes;
 239         write_modes.Add(_T("Erase all, then restore"));
 240         write_modes.Add(_T("Add new, and overwrite existing"));
 241         write_modes.Add(_T("Add only, don't overwrite existing"));
 242         write_modes.Add(_T("Add every record as a new entry (may cause duplicates)"));
 243
 244         dest->Add( new wxStaticText(this, wxID_ANY, _T("Write Mode:")),
 245                 0, wxTOP | wxLEFT | wxRIGHT, 5);
 246         dest->Add( m_write_mode_combo = new wxChoice(this, wxID_ANY,
 247                         wxDefaultPosition, wxSize(225, -1), write_modes),
 248                 0, wxALL, 5);
 249         m_write_mode_combo->SetSelection(0);
 250
 251 //      dest->Add( m_wipe_check = wxCheckBox(maybe a checkbox for "wipe device before restore"));
 252
 253         sizer->Add(dest, 0, wxEXPAND, 0);
 254 }
 255
 256 void MigrateDlg::EnableControls(bool enable)
 257 {
 258         m_source_combo->Enable(enable);
 259         m_dest_combo->Enable(enable);
 260         m_write_mode_combo->Enable(enable);
 261         m_migrate_button->Enable(enable);
 262         //m_wipe_check->Enable(enable);
 263 }
 264
 265 void MigrateDlg::DoSafeClose()
 266 {
 267         // if migrate thread is running, try to close it down first...
 268         // do not exit the dialog until the thread is properly stopped!
 269         if( m_thread_running ) {
 270                 m_abort_flag = true;
 271
 272                 m_status->SetLabel(_T("Waiting for thread to close..."));
 273
 274                 if( m_migrate_thread_created ) {
 275                         void *junk;
 276                         pthread_join(m_migrate_thread, &junk);
 277                         m_migrate_thread_created = false;
 278                 }
 279         }
 280
 281         // all activity is stopped, so close dialog
 282         EndModal(wxID_CANCEL);
 283 }
 284
 285 void MigrateDlg::SendEvent(int event_type)
 286 {
 287         wxCommandEvent event(event_type, wxID_ANY);
 288         event.SetEventObject(this);
 289         AddPendingEvent(event);
 290 }
 291
 292 void MigrateDlg::SendStatusEvent(const wxString &msg, int pos, int max)
 293 {
 294         wxCommandEvent event(MET_SET_STATUS_MSG, wxID_ANY);
 295         event.SetEventObject(this);
 296
 297         event.SetString(msg);
 298
 299         int value = 0;
 300         if( pos == -1 )
 301                 value |= 0xff00;
 302         else
 303                 value |= (pos << 8);
 304
 305         if( max == -1 )
 306                 value |= 0xff;
 307         else
 308                 value |= max & 0xff;
 309         event.SetInt(value);
 310
 311         AddPendingEvent(event);
 312 }
 313
 314 void MigrateDlg::SendErrorMsgEvent(const wxString &msg)
 315 {
 316         wxCommandEvent event(MET_ERROR_MSG, wxID_ANY);
 317         event.SetEventObject(this);
 318         event.SetString(msg);
 319         AddPendingEvent(event);
 320 }
 321
 322 void MigrateDlg::OnMigrateNow(wxCommandEvent &event)
 323 {
 324         // gather info from dialog
 325         int source_index = m_source_combo->GetSelection();
 326         int dest_index = m_dest_combo->GetSelection();
 327         int write_mode_index = m_write_mode_combo->GetSelection();
 328
 329         // validate options
 330         if( source_index == wxNOT_FOUND || dest_index == wxNOT_FOUND ||
 331                 write_mode_index == wxNOT_FOUND )
 332         {
 333                 wxMessageBox(_T("Please select a source and destination device, as well as the write mode."),
 334                         _T("Migration Options Needed"), wxOK | wxICON_ERROR);
 335                 return;
 336         }
 337
 338         // do not migrate from one PIN to the same PIN
 339         if( source_index == (dest_index - 1) ) {
 340                 wxMessageBox(_T("Cannot migrate from and to the same PIN."),
 341                         _T("Migration Options Error"), wxOK | wxICON_ERROR);
 342                 return;
 343         }
 344
 345         // set the migration arguments
 346         m_source_device = &m_results[source_index];
 347         if( dest_index > 0 ) {
 348                 m_dest_device = &m_results[dest_index-1];
 349         }
 350         else {
 351                 m_dest_device = 0; // an invalid dest causes a prompt
 352         }
 353         switch( write_mode_index )
 354         {
 355         case 0:
 356                 m_write_mode = Barry::DeviceParser::ERASE_ALL_WRITE_ALL;
 357                 break;
 358         case 1:
 359                 m_write_mode = Barry::DeviceParser::INDIVIDUAL_OVERWRITE;
 360                 break;
 361         case 2:
 362                 m_write_mode = Barry::DeviceParser::ADD_BUT_NO_OVERWRITE;
 363                 break;
 364         case 3:
 365                 m_write_mode = Barry::DeviceParser::ADD_WITH_NEW_ID;
 366                 break;
 367         default:
 368                 wxMessageBox(_T("Invalid write mode. This should never happen. Contact the developers."),
 369                         _T("Internal Logic Error"), wxOK | wxICON_ERROR);
 370                 return;
 371         }
 372
 373         // disable all buttons and controls except cancel
 374         EnableControls(false);
 375
 376         // turn off the stop flag
 377         m_abort_flag = false;
 378         m_thread_running = false;
 379
 380         // fire up migrate thread, and let the thread close the dialog when
 381         // done  (can we EndModal() from a thread?)
 382         int ret = pthread_create(&m_migrate_thread, NULL,
 383                         &MigrateDlg::MigrateThread, this);
 384         if( ret != 0 ) {
 385                 // go back to normal
 386                 EnableControls(true);
 387                 return;
 388         }
 389         else {
 390                 m_migrate_thread_created = true;
 391         }
 392
 393         // thread started... let it finish
 394 }
 395
 396 void MigrateDlg::OnCancel(wxCommandEvent &event)
 397 {
 398         DoSafeClose();
 399 }
 400
 401 void MigrateDlg::OnCloseWindow(wxCloseEvent &event)
 402 {
 403         DoSafeClose();
 404 }
 405
 406 void MigrateDlg::OnThreadFinished(wxCommandEvent &event)
 407 {
 408         if( m_migrate_thread_created ) {
 409                 m_status->SetLabel(_T("Waiting for thread..."));
 410                 void *junk;
 411                 pthread_join(m_migrate_thread, &junk);
 412                 m_migrate_thread_created = false;
 413         }
 414
 415         if( m_abort_flag ) {
 416                 // user cancelled in some way, restore GUI
 417                 EnableControls(true);
 418                 m_status->SetLabel(_T("Cancelled by user..."));
 419         }
 420         else {
 421                 // if we were not aborted, then this is success, and we
 422                 // can close the original dialog
 423                 EndModal(wxID_CANCEL);
 424         }
 425 }
 426
 427 void MigrateDlg::OnCheckDestPin(wxCommandEvent &event)
 428 {
 429         ScopeSignaler done(m_waiter);
 430
 431         if( m_dest_device && m_dest_device->m_pin.Valid() )
 432                 return; // nothing to do
 433
 434         // no destination pin was available, so user may need to plugin
 435         // the new device right now, before continuing
 436         int response = wxMessageBox(_T("Please plug in the target device now."),
 437                 _T("Ready for Writing"), wxOK | wxCANCEL | wxICON_INFORMATION,
 438                 this);
 439         if( response != wxOK ) {
 440                 // user cancelled
 441                 m_abort_flag = true;
 442                 return;
 443         }
 444
 445         {
 446                 wxBusyCursor wait;
 447                 m_status->SetLabel(_T("Scanning USB for devices..."));
 448
 449                 // pause for 2 seconds to let any new devices settle down
 450                 wxGetApp().Yield();
 451                 wxSleep(2);
 452
 453                 // rescan the USB and try to find the new device
 454                 Barry::Probe probe;
 455                 m_new_results = probe.GetResults();
 456         }
 457
 458         // now prompt the user... create a list of PIN display names
 459         wxArrayString devices;
 460         for( Barry::Probe::Results::const_iterator i = m_new_results.begin();
 461                                 i != m_new_results.end(); ++i )
 462         {
 463                 devices.Add(wxString(i->GetDisplayName().c_str(), wxConvUTF8));
 464         }
 465
 466         m_status->SetLabel(_T("User input..."));
 467
 468         do {
 469
 470                 // prompt the user with this list
 471                 int choice = wxGetSingleChoiceIndex(_T("Please select the target device to write to:"),
 472                         _T("Destination PIN"), devices, this);
 473                 if( choice == -1 ) {
 474                         // user cancelled
 475                         m_abort_flag = true;
 476                         return;
 477                 }
 478
 479                 // found the new PIN to use!
 480                 m_dest_device = &m_new_results[choice];
 481
 482                 // check if user needs to choose again
 483                 if( m_dest_device->m_pin == m_source_device->m_pin ) {
 484                         wxMessageBox(_T("Cannot use the same device PIN as migration destination."),
 485                                 _T("Invalid Device Selection"),
 486                                 wxOK | wxICON_ERROR, this);
 487                 }
 488
 489         } while( m_dest_device->m_pin == m_source_device->m_pin );
 490 }
 491
 492 void MigrateDlg::OnSetStatusMsg(wxCommandEvent &event)
 493 {
 494         if( event.GetString().size() ) {
 495                 m_status->SetLabel(event.GetString());
 496         }
 497
 498         if( (unsigned int)event.GetInt() != 0xffff ) {
 499                 unsigned int value = (unsigned int) event.GetInt();
 500                 unsigned int pos = (value & 0xff00) >> 8;
 501                 unsigned int max = (value & 0xff);
 502
 503                 if( pos != 0xff ) {
 504                         m_progress->SetValue(pos);
 505                 }
 506
 507                 if( max != 0xff ) {
 508                         m_progress->SetRange(max);
 509                 }
 510         }
 511 }
 512
 513 void MigrateDlg::OnPromptPassword(wxCommandEvent &event)
 514 {
 515         ScopeSignaler done(m_waiter);
 516
 517         // create prompt based on exception data
 518         ostringstream oss;
 519         oss << "Please enter device password: ("
 520             << event.GetInt()
 521             << " tries remaining)";
 522         wxString prompt(oss.str().c_str(), wxConvUTF8);
 523
 524         // ask user for device password
 525         m_password = wxGetPasswordFromUser(prompt,
 526                 _T("Device Password"), _T(""), this);
 527 }
 528
 529 void MigrateDlg::OnErrorMsg(wxCommandEvent &event)
 530 {
 531         ScopeSignaler done(m_waiter);
 532         wxMessageBox(event.GetString(), _T("Migration Error"),
 533                 wxOK | wxICON_ERROR, this);
 534 }
 535
 536 void* MigrateDlg::MigrateThread(void *arg)
 537 {
 538         MigrateDlg *us = (MigrateDlg*) arg;
 539
 540         // we are running!
 541         us->m_thread_running = true;
 542
 543         try {
 544                 // backup source PIN
 545                 us->BackupSource();
 546
 547                 // make sure we have a destination PIN
 548                 if( !us->m_abort_flag )
 549                         us->CheckDestPin();
 550
 551                 // restore to dest PIN
 552                 if( !us->m_abort_flag )
 553                         us->RestoreToDest();
 554         }
 555         catch( std::exception &e ) {
 556                 us->SendErrorMsgEvent(wxString(e.what(), wxConvUTF8));
 557                 us->m_waiter.Wait();
 558         }
 559
 560         // invalidate the device selection pointers, since
 561         // m_new_results may not always exist
 562         us->m_source_device = us->m_dest_device = 0;
 563
 564         // we are done!
 565         us->m_thread_running = false;
 566
 567         // send event to let main GUI thread we're finished
 568         us->SendEvent(MET_THREAD_FINISHED);
 569
 570         return 0;
 571 }
 572
 573 class PeekParser : public Barry::Parser
 574 {
 575         std::string m_dbname;
 576
 577 public:
 578         virtual void ParseRecord(const Barry::DBData &data,
 579                                 const Barry::IConverter *ic)
 580         {
 581                 m_dbname = data.GetDBName();
 582         }
 583
 584         const std::string& GetDBName() const { return m_dbname; }
 585 };
 586
 587
 588 // This is called from the thread
 589 void MigrateDlg::BackupSource()
 590 {
 591         // connect to the source device
 592         SendStatusEvent(_T("Connecting..."));
 593         EventDesktopConnector connect(this, "", "utf-8", *m_source_device);
 594         if( !connect.Reconnect(2) ) {
 595                 // user cancelled
 596                 m_abort_flag = true;
 597                 return;
 598         }
 599
 600         // fetch DBDB, for list of databases to backup... back them all up
 601         // remember to save this DBDB into the class, so it is available
 602         // for the restore stage
 603         m_source_dbdb = connect.GetDesktop().GetDBDB();
 604         unsigned int total = m_source_dbdb.GetTotalRecordCount();
 605
 606         // create DeviceBuilder for fetching all
 607         Barry::DeviceBuilder builder(connect.GetDesktop());
 608         builder.Add(m_source_dbdb);
 609
 610         // calculate the default backup path location, based on user name
 611         // (see backup GUI for code?)
 612         Barry::ConfigFile cfg(m_source_device->m_pin);
 613         Barry::ConfigFile::CheckPath(cfg.GetPath());
 614         m_backup_tarfile = cfg.GetPath() + "/" +
 615                 Barry::MakeBackupFilename(m_source_device->m_pin, "migrate");
 616
 617         // and create tarball output parser
 618         Barry::Backup parser(m_backup_tarfile);
 619
 620         // create the pipe
 621         Barry::Pipe pipe(builder);
 622
 623         PeekParser peeker;
 624
 625         // create tee parser, so we can see what's being written
 626         Barry::TeeParser tee;
 627         tee.Add(peeker);
 628         tee.Add(parser);
 629
 630         // setup status bar
 631         unsigned int count = 0;
 632         SendStatusEvent(_T(""), 0, 100);
 633
 634         // cycle through all databases
 635         while( !builder.EndOfFile() ) {
 636                 if( !pipe.PumpEntry(tee) )
 637                         continue;
 638
 639                 count++;
 640
 641                 // ok, first entry has been pumped, so we can use
 642                 // peeker to create the status message, and only once
 643                 ostringstream oss;
 644                 oss << "Backing up database: " << peeker.GetDBName() << "...";
 645
 646                 // calculate 1 to 100 percentage, based on number of
 647                 // databases being backed up, and update status bar too
 648                 int percent = count / (float)total * 100.0;
 649
 650                 // send status event once
 651                 SendStatusEvent(wxString(oss.str().c_str(),wxConvUTF8), percent);
 652
 653                 // backup the rest of the database, but don't update status
 654                 // for each record
 655                 int block = 0;
 656                 while( pipe.PumpEntry(tee) ) {
 657                         count++;
 658                         block++;
 659                         if( block >= 25 ) {
 660                                 int percent = count / (float)total * 100.0;
 661                                 SendStatusEvent(_T(""), percent);
 662                                 block = 0;
 663                         }
 664
 665                         // on each record (pump cycle?), as often as possible,
 666                         // check the m_abort_flag, and abort if necessary,
 667                         // updating the status message
 668                         if( m_abort_flag ) {
 669                                 SendStatusEvent(_T("Backup aborted by user..."));
 670                                 return;
 671                         }
 672                 }
 673         }
 674
 675         // close all files, etc.
 676         parser.Close();
 677 }
 678
 679 // This is called from the thread
 680 void MigrateDlg::CheckDestPin()
 681 {
 682         SendEvent(MET_CHECK_DEST_PIN);
 683         m_waiter.Wait();
 684 }
 685
 686 // This is called from the thread
 687 void MigrateDlg::RestoreToDest()
 688 {
 689         // connect to the dest device
 690         SendStatusEvent(_T("Connecting to target..."));
 691         EventDesktopConnector connect(this, "", "utf-8", *m_dest_device);
 692         if( !connect.Reconnect(2) ) {
 693                 // user cancelled
 694                 m_abort_flag = true;
 695                 return;
 696         }
 697
 698         // fetch DBDB of dest device, for list of databases we can restore
 699         // to... compare with the backup DBDB to create a list of similarly
 700         // named databases which we can restore....
 701         Barry::DatabaseDatabase dest_dbdb = connect.GetDesktop().GetDBDB();
 702
 703         // create the restore builder object, to read from tarball
 704         Barry::Restore builder(m_backup_tarfile);
 705
 706         // add all database names from the _dest_ DBDB to the Restore
 707         // filter... this way, only databases that exist on the new
 708         // device will get restored
 709         builder.Add(dest_dbdb);
 710         unsigned int total = builder.GetRecordTotal();// counts filtered records
 711
 712         // create device parser, to write to device
 713         Barry::DeviceParser parser(connect.GetDesktop(), m_write_mode);
 714
 715         // create the pipe
 716         Barry::Pipe pipe(builder);
 717
 718         // setup status bar
 719         unsigned int count = 0;
 720         SendStatusEvent(_T(""), 0, 100);
 721
 722         // cycle through all databases
 723         Barry::DBData meta;             // record meta data of next tar record
 724         while( !builder.EndOfFile() ) try {
 725                 if( !builder.GetNextMeta(meta) )
 726                         continue;
 727
 728                 // ok, first entry has been pumped, so we can use
 729                 // peeker to create the status message, and only once
 730                 ostringstream oss;
 731                 oss << "Writing database: " << meta.GetDBName() << "...";
 732
 733                 // for debugging purposes in the field, display the names
 734                 // of the databases we restore
 735                 cerr << oss.str() << endl;
 736
 737                 // calculate 1 to 100 percentage, based on number of
 738                 // databases being backed up, and update status bar too
 739                 int percent = count / (float)total * 100.0;
 740
 741                 // send status event once
 742                 SendStatusEvent(wxString(oss.str().c_str(),wxConvUTF8), percent);
 743
 744                 // restore  the rest of the database, but don't update status
 745                 // for each record
 746                 int block = 0;
 747                 while( pipe.PumpEntry(parser) ) {
 748                         count++;
 749                         block++;
 750                         if( block >= 25 ) {
 751                                 int percent = count / (float)total * 100.0;
 752                                 SendStatusEvent(_T(""), percent);
 753                                 block = 0;
 754                         }
 755
 756                         // on each record (pump cycle?), as often as possible,
 757                         // check the m_abort_flag, and abort if necessary,
 758                         // updating the status message
 759                         if( m_abort_flag ) {
 760                                 SendStatusEvent(_T("Restore aborted by user..."));
 761                                 return;
 762                         }
 763                 }
 764         }
 765         catch( Barry::ReturnCodeError &e ) {
 766                 cerr << "Unable to clear or write to database '" << meta.GetDBName() << "'"
 767                         << ": " << e.what() << endl;
 768                 cerr << "Continuing to process remaining records..." << endl;
 769
 770                 // skip the problematic database, and keep on trying
 771                 builder.SkipCurrentDB();
 772         }
 773 }
 774