src/restore.cc

   1 ///
   2 /// \file       restore.cc
   3 ///             Builder class for restoring from Barry Backup files
   4 ///
   5
   6 /*
   7     Copyright (C) 2010-2013, 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 #include "i18n.h"
  23 #include "restore.h"
  24 #include "tarfile.h"
  25 #include "error.h"
  26 #include <sstream>
  27 #include <iomanip>
  28 #include <iostream>
  29 #include <string.h>
  30 #include <algorithm>
  31
  32 using namespace std;
  33
  34 namespace Barry {
  35
  36 namespace {
  37
  38         int CountFiles(reuse::TarFile &tar,
  39                         const Barry::Restore::DBListType &restoreList,
  40                         Barry::Restore::DBListType *available,
  41                         bool default_all_db)
  42         {
  43                 int count = 0;
  44                 std::string name, last_name;
  45                 bool good = false;
  46
  47                 while( tar.ReadNextFilenameOnly(name) ) {
  48                         std::string::size_type pos = name.rfind('/');
  49                         if( pos == std::string::npos )
  50                                 continue;       // bad name
  51                         std::string dbname = name.substr(0, pos);
  52
  53                         if( dbname != last_name ) {
  54                                 last_name = dbname;
  55                                 good = (default_all_db && restoreList.size() == 0) ||
  56                                         restoreList.IsSelected(dbname);
  57
  58                                 if( good && available )
  59                                         available->push_back(dbname);
  60                         }
  61                         if( good )
  62                                 count++;
  63                 }
  64                 return count;
  65         }
  66
  67 }
  68
  69 //////////////////////////////////////////////////////////////////////////////
  70 // Static Restore members
  71
  72 /// Splits a tarpath of the form "DBName/DBID" into separate string values.
  73 /// Returns true if successful, false if tarpath is a bad name.
  74 bool Restore::SplitTarPath(const std::string &tarpath,
  75                                    std::string &dbname,
  76                                    std::string &dbid_text,
  77                                    uint8_t &dbrectype,
  78                                    uint32_t &dbid)
  79 {
  80         std::string::size_type pos = tarpath.rfind('/');
  81         if( pos == std::string::npos )
  82                 return false;           // bad name
  83
  84         dbname = tarpath.substr(0, pos);
  85         dbid_text = tarpath.substr(pos + 1);
  86         if( dbname.size() == 0 || dbid_text.size() == 0 )
  87                 return false;           // bad name
  88
  89         std::istringstream iss(dbid_text);
  90         unsigned int temp;
  91         iss >> std::hex >> dbid >> temp;
  92         dbrectype = (uint8_t) temp;
  93
  94         return true;
  95 }
  96
  97
  98 //////////////////////////////////////////////////////////////////////////////
  99 // Restore - constructors
 100
 101 Restore::Restore(const std::string &tarpath, bool default_all_db)
 102         : m_tarpath(tarpath)
 103         , m_default_all_db(default_all_db)
 104         , m_tar_record_state(RS_EMPTY)
 105         , m_rec_type(0)
 106         , m_unique_id(0)
 107 {
 108         try {
 109                 m_tar.reset( new reuse::TarFile(tarpath.c_str(), false,
 110                                         &reuse::gztar_ops_nonthread, true) );
 111         }
 112         catch( reuse::TarFile::TarError &te ) {
 113                 throw Barry::RestoreError(te.what());
 114         }
 115 }
 116
 117 Restore::~Restore()
 118 {
 119 }
 120
 121
 122 //////////////////////////////////////////////////////////////////////////////
 123 // Restore - Protected helpers
 124
 125 bool Restore::IsSelected(const std::string &dbName) const
 126 {
 127         // if in skip list, always return false,
 128         // if nothing is in the main list, use default
 129         // otherwise, only return true if specifically selected
 130         if( m_dbSkipList.IsSelected(dbName) )
 131                 return false;
 132         else if( m_dbList.size() == 0 )
 133                 return m_default_all_db;
 134         else
 135                 return m_dbList.IsSelected(dbName);
 136 }
 137
 138
 139 //////////////////////////////////////////////////////////////////////////////
 140 // Restore - Public API
 141
 142 void Restore::AddDB(const std::string &dbName)
 143 {
 144         if( find(m_dbList.begin(), m_dbList.end(), dbName) == m_dbList.end() ) {
 145                 // only add it if it is not already in the list
 146                 m_dbList.push_back(dbName);
 147         }
 148 }
 149
 150 void Restore::Add(const DBListType &dbList)
 151 {
 152         for( DBListType::const_iterator i = dbList.begin();
 153                 i != dbList.end();
 154                 ++i )
 155         {
 156                 AddDB(*i);
 157         }
 158 }
 159
 160 void Restore::Add(const DatabaseDatabase &dbdb)
 161 {
 162         for( DatabaseDatabase::DatabaseArrayType::const_iterator i = dbdb.Databases.begin();
 163                 i != dbdb.Databases.end();
 164                 ++i )
 165         {
 166                 AddDB(i->Name);
 167         }
 168 }
 169
 170 void Restore::AddSkipDB(const std::string &dbName)
 171 {
 172         if( find(m_dbSkipList.begin(), m_dbSkipList.end(), dbName) == m_dbSkipList.end() ) {
 173                 // only add it if it is not already in the list
 174                 m_dbSkipList.push_back(dbName);
 175         }
 176 }
 177
 178 void Restore::SkipCurrentDB()
 179 {
 180         // skip all records until next DB
 181         try {
 182                 Restore::RetrievalState state;
 183                 while( (state = Retrieve(m_record_data)) == RS_NEXT ) {
 184                         std::cerr << _("Skipping: ")
 185                                 << m_current_dbname << "/"
 186                                 << m_tar_id_text << std::endl;
 187                         m_tar_record_state = RS_EMPTY;
 188                 }
 189
 190                 if( state == RS_DBEND ) {
 191                         // process the end of database, so that user is free
 192                         // to call GetNextMeta() or Retrieve() or BuildRecord()
 193                         m_tar_record_state = RS_NEXT;
 194                 }
 195         }
 196         catch( reuse::TarFile::TarError & ) {
 197                 m_tar_record_state = RS_EOF;
 198         }
 199 }
 200
 201 unsigned int Restore::GetRecordTotal() const
 202 {
 203         return GetRecordTotal(m_tarpath, m_dbList, m_default_all_db);
 204 }
 205
 206 unsigned int Restore::GetRecordTotal(const std::string &tarpath,
 207                                         const DBListType &dbList,
 208                                         bool default_all_db)
 209 {
 210         unsigned int count = 0;
 211
 212         std::auto_ptr<reuse::TarFile> tar;
 213
 214         try {
 215                 // do a scan through the tar file
 216                 tar.reset( new reuse::TarFile(tarpath.c_str(), false,
 217                                 &reuse::gztar_ops_nonthread, true) );
 218                 count = CountFiles(*tar, dbList, 0, default_all_db);
 219         }
 220         catch( reuse::TarFile::TarError &te ) {
 221                 throw Barry::RestoreError(te.what());
 222         }
 223         return count;
 224 }
 225
 226 Barry::Restore::DBListType Restore::GetDBList() const
 227 {
 228         return GetDBList(m_tarpath);
 229 }
 230
 231 Barry::Restore::DBListType Restore::GetDBList(const std::string &tarpath)
 232 {
 233         std::auto_ptr<reuse::TarFile> tar;
 234         DBListType available, empty;
 235
 236         try {
 237                 // do a scan through the tar file
 238                 tar.reset( new reuse::TarFile(tarpath.c_str(), false,
 239                                 &reuse::gztar_ops_nonthread, true) );
 240                 CountFiles(*tar, empty, &available, true);
 241                 return available;
 242         }
 243         catch( reuse::TarFile::TarError &te ) {
 244                 throw Barry::RestoreError(te.what());
 245         }
 246 }
 247
 248 bool Restore::GetNextMeta(DBData &data)
 249 {
 250         // always use m_record_data here, so that we don't lose access
 251         // to the actual record data for future calls to BuildRecord()
 252         // and FetchRecord()
 253         if( m_tar_record_state == RS_EMPTY ) {
 254                 Retrieve(m_record_data);
 255         }
 256
 257         // fill in the meta data that will be returned in the next call
 258         // to BuildRecord() or FetchRecord()... this is only valid if
 259         // the state is RS_NEXT
 260         switch( m_tar_record_state )
 261         {
 262         case RS_NEXT:
 263                 data.SetVersion(Barry::DBData::REC_VERSION_1);
 264                 data.SetDBName(m_current_dbname);
 265                 data.SetIds(m_rec_type, m_unique_id);
 266                 data.SetOffset(0);
 267                 return true;
 268
 269         default:
 270                 return false;
 271         }
 272 }
 273
 274
 275 //////////////////////////////////////////////////////////////////////////////
 276 // Barry::Builder overrides
 277
 278 Restore::RetrievalState Restore::Retrieve(Data &record_data)
 279 {
 280         // don't do anything unless we're empty
 281         if( m_tar_record_state != RS_EMPTY )
 282                 return m_tar_record_state;
 283
 284         // search for a valid record
 285         for(;;) {
 286                 // load record data from tar file
 287                 std::string filename;
 288                 if( !m_tar->ReadNextFile(filename, record_data) ) {
 289                         // assume end of file
 290                         return m_tar_record_state = RS_EOF;
 291                 }
 292                 m_tar_record_state = RS_UNKNOWN;
 293
 294                 // split record filename into dbname and ID
 295                 std::string dbname;
 296                 if( !SplitTarPath(filename, dbname, m_tar_id_text, m_rec_type, m_unique_id) ) {
 297                         // invalid filename, skip it
 298                         std::cerr << _("Skipping invalid tar record: ") << filename << std::endl;
 299                         continue;
 300                 }
 301
 302                 // are we working on the same dbname as last time?
 303                 // if so, go ahead!
 304                 if( m_current_dbname == dbname ) {
 305                         return m_tar_record_state = RS_NEXT;
 306                 }
 307
 308                 // DIFFERENT DBNAME from here on down!
 309                 m_tar_record_state = RS_DBEND;
 310
 311                 // does the filter allow this record?
 312                 // if not, skip it and continue looking
 313                 if( !IsSelected(dbname) ) {
 314                         continue;
 315                 }
 316
 317                 // all checks pass, load the new dbname, and return DBEND
 318                 // if we are on a dbname boundary
 319                 if( m_current_dbname.size() == 0 ) {
 320                         // this is the first time through Retrieve, so ok
 321                         m_tar_record_state = RS_NEXT;
 322                 }
 323
 324                 m_current_dbname = dbname;
 325                 return m_tar_record_state;
 326         }
 327 }
 328
 329 bool Restore::BuildRecord(Barry::DBData &data,
 330                           size_t &offset,
 331                           const Barry::IConverter *ic)
 332 {
 333         // in this case, we are loading into m_record_data anyway,
 334         // so no special handling is needed, like FetchRecord() needs.
 335         switch( Retrieve(m_record_data) )
 336         {
 337         case RS_NEXT:
 338                 {
 339                         data.SetVersion(Barry::DBData::REC_VERSION_1);
 340                         data.SetDBName(m_current_dbname);
 341                         data.SetIds(m_rec_type, m_unique_id);
 342                         data.SetOffset(offset);
 343
 344                         int packet_size = offset + m_record_data.GetSize();
 345                         unsigned char *buf = data.UseData().GetBuffer(packet_size);
 346                         memcpy(buf + offset, m_record_data.GetData(), m_record_data.GetSize());
 347                         offset += m_record_data.GetSize();
 348                         data.UseData().ReleaseBuffer(packet_size);
 349
 350                         // clear loaded flag, as it has now been used
 351                         m_tar_record_state = RS_EMPTY;
 352                         return true;
 353                 }
 354
 355         case RS_EMPTY:
 356         case RS_UNKNOWN:
 357         default:
 358                 throw std::logic_error(_("Invalid state in Restore::BuildRecord()"));
 359
 360         case RS_DBEND:
 361                 // process the end of database by returning false
 362                 // the next round will be valid, so set to RS_NEXT
 363                 m_tar_record_state = RS_NEXT;
 364                 return false;
 365
 366         case RS_EOF:
 367                 // always return false at end of file
 368                 return false;
 369         }
 370 }
 371
 372 bool Restore::FetchRecord(Barry::DBData &data, const Barry::IConverter *ic)
 373 {
 374         // if the record has not yet been loaded, we can optimize
 375         // the buffer, and pass in our own... otherwise, just copy
 376         // the current buffer from m_record_data
 377         //
 378         // it is assumed here that Builder users will not alternate
 379         // between calls to BuildRecord() and FetchRecord()
 380         //
 381         if( m_tar_record_state == RS_EMPTY ) {
 382                 // BUT, if RS_DBEND is the next value, then we need
 383                 // to save the data for the next round... this
 384                 // optimization is almost more bother than it's worth :-)
 385                 if( Retrieve(data.UseData()) == RS_DBEND ) {
 386                         m_record_data = data.GetData();
 387                         m_tar_record_state = RS_NEXT;
 388                         return false;
 389                 }
 390         }
 391         else {
 392                 data.UseData() = m_record_data;
 393         }
 394
 395         switch( m_tar_record_state )
 396         {
 397         case RS_NEXT:
 398                 data.SetVersion(Barry::DBData::REC_VERSION_1);
 399                 data.SetDBName(m_current_dbname);
 400                 data.SetIds(m_rec_type, m_unique_id);
 401                 data.SetOffset(0);
 402
 403                 // clear loaded flag, as it has now been used
 404                 m_tar_record_state = RS_EMPTY;
 405                 return true;
 406
 407         case RS_EMPTY:
 408         case RS_UNKNOWN:
 409         default:
 410                 throw std::logic_error(_("Invalid state in Restore::FetchRecord()"));
 411
 412         case RS_DBEND:
 413                 // process the end of database by returning false
 414                 // the next round will be valid, so set to RS_NEXT
 415                 m_tar_record_state = RS_NEXT;
 416                 return false;
 417
 418         case RS_EOF:
 419                 // always return false at end of file
 420                 return false;
 421         }
 422 }
 423
 424 bool Restore::EndOfFile() const
 425 {
 426         return m_tar_record_state == RS_EOF;
 427 }
 428
 429 } // namespace Barry
 430