hsm_IVDFSRecoverer Class Reference
[G_new_group]

#include <hsm_IVDFSRecoverer.h>

Inheritance diagram for hsm_IVDFSRecoverer:

Inheritance graph
[legend]
Collaboration diagram for hsm_IVDFSRecoverer:

Collaboration graph
[legend]

List of all members.

Detailed Description

Definition at line 33 of file hsm_IVDFSRecoverer.h.


Public Member Functions

 hsm_IVDFSRecoverer (UInt32_t a_blkSize)
 ~hsm_IVDFSRecoverer (void)

Private Member Functions

virtual void ProcRecFileHdr (const df_RecCmn_t *a_recCmn_p)
void CreateFile (cmn_Path &a_fileName, ivd_RecordIDX_t &a_fileID)
virtual void ProcRecFileEnd (const df_RecCmn_t *a_recCmn_p)
virtual void ProcRecBSStart (const df_RecCmn_t *a_recCmn_p)
virtual void ProcRecEmbData (const df_RecCmn_t *a_recCmn_p)
virtual void ProcRecRawData (const UInt8_t *a_block_p)
virtual void ProcRecBSEnd (const df_RecCmn_t *a_recCmn_p)

Private Attributes

 log_CLASSID_m
 Macro to add class name member s_className.
ivd_FS_File * m_recovFile_p
ivd_FileInfo_t m_fileInfo
ivd_RecordIDX_t m_fileID

Constructor & Destructor Documentation

hsm_IVDFSRecoverer::hsm_IVDFSRecoverer ( UInt32_t  a_blkSize  ) 

Definition at line 38 of file hsm_IVDFSRecoverer.cpp.

00039     :
00040     df_RecReader(new df_BlockProxy(blk_FSRec_c, bbt_DISK_FRI_RECOVERY, a_blkSize)),
00041     m_recovFile_p(NULL)
00042 {
00043 
00044 }
//============================================================================//

hsm_IVDFSRecoverer::~hsm_IVDFSRecoverer ( void   ) 

Definition at line 47 of file hsm_IVDFSRecoverer.cpp.

References m_recovFile_p, and NULL.

00048 {
00049     if (m_recovFile_p) {
00050         delete m_recovFile_p;
00051         m_recovFile_p = NULL;
00052     }
00053 }

Member Function Documentation

void hsm_IVDFSRecoverer::ProcRecFileHdr ( const df_RecCmn_t *  a_recCmn_p  )  [private, virtual]

Reimplemented from df_RecReader.

Definition at line 56 of file hsm_IVDFSRecoverer.cpp.

References df_StandardAttr_t::attr, cmn_CreatePath(), cmn_CreatePathNoException(), cmn_MoveFile(), cmn_UTF8ToLocale(), CreateFile(), dbg_DETAIL, dbg_NORM, ivd_FS_File::e_Cache, ivd_FS_File::e_Recovery, cmn_File::Exists(), g_fs_api_p, ivd_BaseException::GetError(), ivd_FS_File::GetProperties(), ivd_FileSystemAPI::GetRootPath(), df_RecCmn_t::GetVarDataNet(), df_StandardAttr_t::group, df_RecFile_t::idFile, ift_DIR, log_DBG_m, log_FUNC_m, log_WRN_m, m_fileID, ivd_FS_FileProperty_t::m_fileID, m_fileInfo, m_recovFile_p, df_RecFile_t::name, df_StandardAttr_t::NetToHost(), ntoh(), NULL, ivd_FS_File::Open(), df_StandardAttr_t::owner, ivd_FS_File::SetInode(), df_StandardAttr_t::size, ivd_FS_File::StatF(), df_RecFile_t::stdAttr, df_StandardAttr_t::timeAccess, df_StandardAttr_t::timeChange, df_StandardAttr_t::timeCreate, df_StandardAttr_t::timeModify, and df_StandardAttr_t::type.

00056                                                                     {
00057     log_FUNC_m(ProcRecFileHdr);
00058 
00059     if (m_recovFile_p != NULL) {
00060         delete m_recovFile_p;
00061     }
00062 
00063     const df_RecFile_t *file_p = df_GetSpecificRec<df_RecFile_t>(a_recCmn_p);
00064 
00065     ivd_RecordIDX_t fileID = static_cast<ivd_RecordIDX_t>(ntoh(file_p->idFile));
00066 
00067     cmn_Path entryName(g_fs_api_p->GetRootPath() + a_recCmn_p->GetVarDataNet(file_p->name));
00068 #if IVD_POSIX_OS
00069     cmn_Path localeName(cmn_UTF8ToLocale(entryName));
00070     entryName = localeName;
00071 #endif
00072 
00073     df_StandardAttr_t attr = file_p->stdAttr;
00074     attr.NetToHost();
00075 
00076     ivd_FileType_e dfAttrType = static_cast<ivd_FileType_e>(attr.type);
00077 
00078     m_recovFile_p = new ivd_FS_File(*g_fs_api_p, entryName, 0, attr.size, dfAttrType);
00079 
00080     ivd_FS_FileProperty_t fileProp;
00081     bool entryExists(false);
00082 
00083     // Verify if the entry already exists
00084 
00085     cmn_File entry(entryName);
00086     entryExists = entry.Exists();
00087 
00088     if (!entryExists) {
00089         log_DBG_m(dbg_DETAIL, "Entry " << entryName << " doesn't exist yet.");
00090     }
00091     else {
00092         m_recovFile_p->StatF(m_fileInfo);
00093         m_recovFile_p->SetInode(m_fileInfo.idOnFS);
00094         m_recovFile_p->GetProperties(fileProp);
00095 
00096         if (dfAttrType != m_fileInfo.type) {
00097             log_WRN_m(
00098                 "Existing entry " << entryName
00099                 << " has different type than the one from FSC. "
00100                 << "fs = " << m_fileInfo.type
00101                 << ", FSC = " << dfAttrType);
00102         }
00103 
00104         if (fileProp.m_fileID == fileID) {
00105             if (m_fileInfo.size != attr.size) {
00106                 log_DBG_m(dbg_NORM,
00107                     "Existing entry "<< entryName << " has appropriate fileID"
00108                     << " but different size: fs = " << m_fileInfo.size
00109                     << ", FSC = " << attr.size);
00110             }
00111             else {
00112                 log_DBG_m(dbg_NORM,
00113                     "Existing entry "<< entryName << " has appropriate fileID and size.");
00114             }
00115             delete m_recovFile_p;
00116             m_recovFile_p = NULL;
00117 
00118             return;
00119         }
00120         else {
00121             // Rename existing directory or file
00122             log_DBG_m(dbg_NORM,
00123                 "Existing item "<< entryName << " already has fileID "
00124                 << fileProp.m_fileID << ".");
00125 
00126             ostringstream newName;
00127             newName << entryName << "_HSM_RECOVERY_" << fileProp.m_fileID;
00128 
00129             if (dfAttrType != ift_DIR || fileProp.m_fileID != 0) {
00130                 log_DBG_m(dbg_DETAIL, "Renaming to " << newName.str());
00131                 cmn_MoveFile(entryName, newName.str());
00132             }
00133             else {
00134                 log_DBG_m(dbg_DETAIL, "Directories with fileID 0 are not renamed.");
00135             }
00136 
00137             // We have handled existing entry on the file system.
00138             entryExists = false;
00139         }
00140     }
00141 
00142     // Create directory or file
00143     if (dfAttrType == ift_DIR) {
00144 
00145         log_DBG_m(dbg_DETAIL,
00146             "Recovery of directory " << entryName << " fileID = " << fileID);
00147 
00148         if (!entryExists) {
00149             try {
00150                 // create a dir
00151                 cmn_CreatePath(entryName);
00152                 m_recovFile_p->StatF(m_fileInfo);
00153                 m_recovFile_p->SetInode(m_fileInfo.idOnFS);
00154                 m_recovFile_p->GetProperties(fileProp);
00155             }
00156             catch (const ivd_Exception &ie) {
00157                 log_WRN_m("Creating directory failed."
00158                     << " error "  << ie.GetError()
00159                     << " FileID " << fileID
00160                     << " Name "   << entryName );
00161 
00162                 delete m_recovFile_p;
00163                 m_recovFile_p = NULL;
00164             };
00165         }
00166 
00167 #ifdef TGT_OS_windows
00168         // directory is opened for restoring streams.
00169         m_recovFile_p->Open(ivd_FS_File::e_Recovery);
00170 #else
00171         //HPUX - Directory needs to be opened ( to be in the kernel cache ).
00172         m_recovFile_p->Open(ivd_FS_File::e_Cache, entryName);
00173 #endif
00174     }
00175     else { // file
00176         log_DBG_m(dbg_DETAIL,
00177             "Recovery of file " << entryName << " fileID = " << fileID);
00178 
00179         if (!entryExists) {
00180             try {
00181                 cmn_Path dirName(entryName.UpPath());
00182                 cmn_File dir(dirName);
00183 
00184                 if (!dir.Exists()) {
00185                     // Creating parent directories
00186                     // FileID will follow and will be set later
00187                     log_DBG_m(dbg_DETAIL,
00188                         "Parent directory doesn't exist yet. Creating: " << dirName);
00189 
00190                     cmn_CreatePathNoException(dirName);
00191                 }
00192                 CreateFile(entryName, fileID);
00193             }
00194             catch (const ivd_Exception& ie) {
00195                 log_WRN_m("Creating file failed."
00196                     << " error "  << ie.GetError()
00197                     << " FileID " << fileID
00198                     << " Name "   << entryName );
00199 
00200                 delete m_recovFile_p;
00201                 m_recovFile_p = NULL;
00202             }
00203         }
00204         else {
00205             log_DBG_m(dbg_NORM, "File already exists with file ID 0: " << entryName);
00206         }
00207     }
00208 
00209     // When we get to this point, the directory or file without file ID exists.
00210     // File ID will be set in ProcRecFileEnd.
00211 
00212     m_fileInfo.size         = attr.size;
00213     m_fileInfo.attr         = attr.attr;
00214     m_fileInfo.owner        = attr.owner;
00215     m_fileInfo.group        = attr.group;
00216 
00217     m_fileInfo.timeCreate   = attr.timeCreate;
00218     m_fileInfo.timeAccess   = attr.timeAccess;
00219     m_fileInfo.timeModify   = attr.timeModify;
00220     m_fileInfo.timeChange   = attr.timeChange;
00221 
00222     m_fileInfo.type         = dfAttrType;
00223 
00224     m_fileID = fileID;
00225 }

Here is the call graph for this function:

void hsm_IVDFSRecoverer::CreateFile ( cmn_Path &  a_fileName,
ivd_RecordIDX_t &  a_fileID 
) [private]

Definition at line 229 of file hsm_IVDFSRecoverer.cpp.

References ivd_FS_File::Close(), dbg_DETAIL, ivd_FS_File::e_Recovery, ivd_BaseException::GetError(), ivd_BaseException::GetFriendly(), ivd_FS_File::GetProperties(), IVD_PRINT_ID_FS, log_DBG_m, log_FUNC_m, log_WRN_m, ivd_FS_FileProperty_t::m_chgTime, ivd_FS_FileProperty_t::m_dirtyFlag, m_fileInfo, ivd_FS_FileProperty_t::m_offlineFlag, m_recovFile_p, NULL, ivd_FS_File::Open(), ivd_FS_File::SetInode(), and ivd_FS_File::StatF().

Referenced by ProcRecFileHdr().

00229                                                                                   {
00230     log_FUNC_m(CreateFile);
00231 
00232     try {
00233         m_recovFile_p->Open(ivd_FS_File::e_Recovery);
00234     }
00235     catch (ivd_SysError &ie) { //
00236         log_DBG_m(dbg_DETAIL, " Can't open file to recover " << a_fileName
00237             << " error " << ie.GetError());
00238         log_WRN_m("Can't open file to recover"
00239             << " error "  << ie.GetFriendly()
00240             << " FileID " << a_fileID
00241             << " Name "   << a_fileName );
00242 
00243         delete m_recovFile_p;
00244         m_recovFile_p = NULL;
00245         return;
00246     }
00247 
00248     log_DBG_m(dbg_DETAIL, " Get its stat." );
00249     m_recovFile_p->StatF(m_fileInfo);
00250 
00251     ivd_FS_FileProperty_t fileProp;
00252     log_DBG_m(dbg_DETAIL, " Get properties. inode = " << IVD_PRINT_ID_FS(m_fileInfo.idOnFS));
00253 
00254     // setting inode for GetProperties()
00255     m_recovFile_p->SetInode(m_fileInfo.idOnFS);
00256 
00257     try {
00258         m_recovFile_p->GetProperties(fileProp); // just to set proper general inode (FSid)
00259     }
00260     catch (const ivd_SysError &ie) { // Catch failures from file system.
00261 
00262         log_DBG_m(dbg_DETAIL,  " GetProperties failed. FileName = " << a_fileName
00263             << " error = " << ie.GetError());
00264 
00265         log_WRN_m("GetProperties failed."
00266             << " error "  << ie.GetError()
00267             << " FileID " << a_fileID
00268             << " Name "   << a_fileName );
00269 
00270         m_recovFile_p->Close();
00271 
00272         delete m_recovFile_p;
00273         m_recovFile_p = NULL;
00274 
00275         return;
00276     };
00277 
00278     log_DBG_m(dbg_DETAIL,  " m_dirtyFlag = " << fileProp.m_dirtyFlag
00279         << " m_offlineFlag = " << fileProp.m_offlineFlag
00280         << " m_chg_time = " << fileProp.m_chgTime);
00281 
00282 }//Createfile

Here is the call graph for this function:

Here is the caller graph for this function:

void hsm_IVDFSRecoverer::ProcRecFileEnd ( const df_RecCmn_t *  a_recCmn_p  )  [private, virtual]

Reimplemented from df_RecReader.

Definition at line 285 of file hsm_IVDFSRecoverer.cpp.

References ivd_FS_File::Close(), dbg_DETAIL, ivd_FS_File::e_Cache, ivd_BaseException::GetError(), ivd_FS_File::GetFullPathRef(), ivd_FS_File::GetProperties(), ift_DIR, log_DBG_m, log_FUNC_m, log_WRN_m, ivd_FS_FileProperty_t::m_chgTime, m_fileID, m_fileInfo, m_recovFile_p, NULL, ivd_FS_File::Open(), ivd_FS_File::Release(), ivd_FS_File::SetDataClean(), ivd_FS_File::SetDataOffline(), ivd_FS_File::SetFileID(), ivd_FS_File::SetFileSize(), and ivd_FS_File::SetStatAttr().

00285                                                                     {
00286     log_FUNC_m(ProcRecFileEnd);
00287 
00288     if (m_recovFile_p == NULL) {
00289         log_DBG_m(dbg_DETAIL, "No recovery in progress: " <<  m_fileID);
00290         return;
00291     }
00292 
00293     try {
00294         log_DBG_m(dbg_DETAIL, " Set fileID = " <<  m_fileID);
00295         m_recovFile_p->SetFileID(m_fileID, m_fileInfo.size);
00296     }
00297     catch (ivd_SysError) {
00298         log_WRN_m(
00299             "Setting file ID failed for entry: "
00300             << m_recovFile_p->GetFullPathRef()
00301             << " fileID: " << m_fileID );
00302     }
00303 
00304     if (m_fileInfo.type != ift_DIR) {
00305 #ifdef TGT_OS_windows
00306         // File is dirty by default on NT. See also Bug#1275.
00307         ivd_FS_FileProperty_t fileProp;
00308 
00309         try {
00310             m_recovFile_p->GetProperties(fileProp); // Could also modify filter to accept 0 for chgTime.
00311         }
00312         catch (ivd_SysError &ie) { // Catch failures from file system.
00313 
00314             log_DBG_m(dbg_DETAIL,  " GetProperties failed. FileName = "
00315                 << " error = " << ie.GetError());
00316 
00317             log_WRN_m("GetProperties failed."
00318                 << " error "  << ie.GetError() );
00319 
00320             m_recovFile_p->Close();
00321             return;
00322         };
00323 
00324         m_recovFile_p->SetDataClean(fileProp.m_chgTime, 0, m_fileInfo.size);
00325 #endif
00326         // Zero size files are recovered as online.
00327         if (m_fileInfo.size > 0) {
00328             try {
00329                 log_DBG_m(dbg_DETAIL, " Set data offline of size " << m_fileInfo.size);
00330                 m_recovFile_p->SetFileSize(m_fileInfo.size);
00331                 m_recovFile_p->Release();
00332                 m_recovFile_p->Close();
00333             }
00334             catch (ivd_SysError) { //
00335             }
00336 
00337             try {
00338                 //HPUX - The file needs to be opened ( to be in the kernel cache ).
00339                 m_recovFile_p->Open(ivd_FS_File::e_Cache);
00340                 m_recovFile_p->SetDataOffline(0, m_fileInfo.size);
00341             }
00342             catch (ivd_SysError) { //
00343             }
00344             m_recovFile_p->Close();
00345         }
00346         else {
00347             m_recovFile_p->Close();
00348             log_DBG_m(dbg_DETAIL, " File is zero length. Leave online.");
00349         }
00350     }
00351 #ifdef TGT_OS_windows
00352     else { // directory is opened for restoring streams.
00353         m_recovFile_p->Close();
00354     }
00355 #endif
00356 
00357     try {
00358         log_DBG_m(dbg_DETAIL, " Set standard attributes." );
00359         m_recovFile_p->SetStatAttr(m_fileInfo);
00360     }
00361     catch (ivd_SysError) { //
00362     }
00363 }

Here is the call graph for this function:

void hsm_IVDFSRecoverer::ProcRecBSStart ( const df_RecCmn_t *  a_recCmn_p  )  [private, virtual]

Reimplemented from df_RecReader.

Definition at line 366 of file hsm_IVDFSRecoverer.cpp.

References cmn_Num2Str(), dbg_DETAIL, df_ST_ALTDATA, df_ST_META, df_RecCmn_t::GetVarDataNet(), ie_IMPOSSIBLE, log_DBG_m, log_FUNC_m, df_RecReader::m_curStreamName, m_fileID, m_recovFile_p, ntoh(), NULL, ivd_FS_File::SetStreamHeader(), df_RecByteStreamStart_t::streamName, df_RecByteStreamStart_t::streamSize, df_RecByteStreamStart_t::streamType, and stt_META.

00366                                                                      {
00367     log_FUNC_m(ProcRecBSStart);
00368 
00369     if (m_recovFile_p == NULL) {
00370         log_DBG_m(dbg_DETAIL, "No recovery in progress: " <<  m_fileID);
00371         return;
00372     }
00373 
00374     const df_RecByteStreamStart_t *bss_p = df_GetSpecificRec<df_RecByteStreamStart_t>(a_recCmn_p);
00375     UInt32_t streamType = ntoh(bss_p->streamType);
00376     if (streamType == df_ST_META) {
00377         string streamName = a_recCmn_p->GetVarDataNet(bss_p->streamName);
00378 //        if (m_lastStreamName == c_df_StreamNameMetaWinACL) {
00379         m_recovFile_p->SetStreamHeader(stt_META, streamName.c_str(), ntoh(bss_p->streamSize));
00380     }
00381     else if (streamType == df_ST_ALTDATA) {
00382         log_DBG_m(dbg_DETAIL, "ADS are not recovered. ADS name '" << m_curStreamName << "'" );
00383         // TODO set an offline flag for ADS
00384     }
00385     else {
00386         throw ivd_InternalError(ie_IMPOSSIBLE,
00387             "Invalid stream type from data format: " +
00388             cmn_Num2Str(streamType));
00389     }
00390 }

Here is the call graph for this function:

void hsm_IVDFSRecoverer::ProcRecEmbData ( const df_RecCmn_t *  a_recCmn_p  )  [private, virtual]

Reimplemented from df_RecReader.

Definition at line 393 of file hsm_IVDFSRecoverer.cpp.

References df_RecEmbeddedData_t::data, dbg_DETAIL, df_RecCmn_t::GetVarDataNet(), log_DBG_m, log_FUNC_m, m_fileID, m_recovFile_p, ntoh(), NULL, ivd_VarData_t::size, size, and ivd_FS_File::WriteStream().

00393                                                                      {
00394     log_FUNC_m(ProcRecEmbData);
00395 
00396     if (m_recovFile_p == NULL) {
00397         log_DBG_m(dbg_DETAIL, "No recovery in progress: " <<  m_fileID);
00398         return;
00399     }
00400 
00401     const df_RecEmbeddedData_t *embData_p = df_GetSpecificRec<df_RecEmbeddedData_t>(a_recCmn_p);
00402     UInt32_t size = ntoh(embData_p->data.size);
00403 
00404     UInt32_t written;
00405     written = m_recovFile_p->WriteStream((void *)const_cast<char*>(a_recCmn_p->GetVarDataNet(embData_p->data)), size);
00406 
00407 }

Here is the call graph for this function:

void hsm_IVDFSRecoverer::ProcRecRawData ( const UInt8_t *  a_block_p  )  [private, virtual]

Reimplemented from df_RecReader.

Definition at line 410 of file hsm_IVDFSRecoverer.cpp.

References dbg_DETAIL, df_RecReader::GetBlkSize(), log_DBG_m, log_FUNC_m, m_fileID, m_recovFile_p, NULL, and ivd_FS_File::WriteStream().

00410                                                                 {
00411     log_FUNC_m(ProcRecRawData);
00412 
00413     if (m_recovFile_p == NULL) {
00414         log_DBG_m(dbg_DETAIL, "No recovery in progress: " <<  m_fileID);
00415         return;
00416     }
00417 
00418     UInt32_t written;
00419     written = m_recovFile_p->WriteStream((void *)const_cast<UInt8_t*>(a_block_p), GetBlkSize());
00420 
00421 }

Here is the call graph for this function:

void hsm_IVDFSRecoverer::ProcRecBSEnd ( const df_RecCmn_t *  a_recCmn_p  )  [private, virtual]

Reimplemented from df_RecReader.

Definition at line 424 of file hsm_IVDFSRecoverer.cpp.

References dbg_DETAIL, df_ST_ALTDATA, df_RecCmn_t::GetVarDataNet(), log_DBG_m, log_FUNC_m, df_RecReader::m_curStreamType, m_fileID, m_recovFile_p, NULL, and df_RecByteStreamEnd_t::streamName.

00424                                                                    {
00425     log_FUNC_m(ProcRecBSEnd);
00426 
00427     if (m_recovFile_p == NULL) {
00428         log_DBG_m(dbg_DETAIL, "No recovery in progress: " <<  m_fileID);
00429         return;
00430     }
00431 
00432     if (m_curStreamType == df_ST_ALTDATA) {
00433         return;
00434     }
00435     const df_RecByteStreamEnd_t *bse_p = df_GetSpecificRec<df_RecByteStreamEnd_t>(a_recCmn_p);
00436     string streamName = a_recCmn_p->GetVarDataNet(bse_p->streamName);
00437 }

Here is the call graph for this function:

Member Data Documentation

hsm_IVDFSRecoverer::log_CLASSID_m [private]

Macro to add class name member s_className.

Reimplemented from df_RecReader.

Definition at line 38 of file hsm_IVDFSRecoverer.h.

ivd_FS_File* hsm_IVDFSRecoverer::m_recovFile_p [private]

Definition at line 40 of file hsm_IVDFSRecoverer.h.

Referenced by CreateFile(), ProcRecBSEnd(), ProcRecBSStart(), ProcRecEmbData(), ProcRecFileEnd(), ProcRecFileHdr(), ProcRecRawData(), and ~hsm_IVDFSRecoverer().

ivd_FileInfo_t hsm_IVDFSRecoverer::m_fileInfo [private]

Definition at line 41 of file hsm_IVDFSRecoverer.h.

Referenced by CreateFile(), ProcRecFileEnd(), and ProcRecFileHdr().

ivd_RecordIDX_t hsm_IVDFSRecoverer::m_fileID [private]

Definition at line 42 of file hsm_IVDFSRecoverer.h.

Referenced by ProcRecBSEnd(), ProcRecBSStart(), ProcRecEmbData(), ProcRecFileEnd(), ProcRecFileHdr(), and ProcRecRawData().

The documentation for this class was generated from the following files:
Generated on Mon Feb 27 19:28:31 2012 for OPENARCHIVE by  doxygen 1.5.6