src/restore.cc

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