backuphelper.cpp

Go to the documentation of this file.

#include "./backuphelper.h"
#include "./diagnostics.h"
#include "./mediafileinfo.h"
 
#include <c++utilities/conversion/stringbuilder.h>
#include <c++utilities/conversion/stringconversion.h>
#include <c++utilities/io/path.h>
 
#include <cstdio>
#include <filesystem>
#include <fstream>
#include <stdexcept>
#include <string>
 
using namespace std;
using namespace CppUtilities;
 
namespace TagParser {
 
namespace BackupHelper {
 
void restoreOriginalFileFromBackupFile(
    const std::string &originalPath, const std::string &backupPath, NativeFileStream &originalStream, NativeFileStream &backupStream)
{
    // ensure streams are closed but don't handle any errors anymore at this point
    originalStream.exceptions(ios_base::goodbit);
    backupStream.exceptions(ios_base::goodbit);
    originalStream.close();
    backupStream.close();
    originalStream.clear();
    backupStream.clear();
 
    // restore usual exception handling of the streams
    originalStream.exceptions(ios_base::badbit | ios_base::failbit);
    backupStream.exceptions(ios_base::badbit | ios_base::failbit);
 
    // check whether backup file actually exists and close the backup stream afterwards
    const auto originalPathForOpen = std::filesystem::path(makeNativePath(BasicFileInfo::pathForOpen(originalPath)));
    const auto backupPathForOpen = std::filesystem::path(makeNativePath(BasicFileInfo::pathForOpen(backupPath)));
    auto ec = std::error_code();
    if (!std::filesystem::exists(backupPathForOpen, ec) && !ec) {
        throw std::ios_base::failure("Backup/temporary file has not been created.");
    }
 
    // remove original file and restore backup
    std::filesystem::remove(originalPathForOpen, ec);
    if (ec) {
        throw std::ios_base::failure("Unable to remove original file: " + ec.message());
    }
    std::filesystem::rename(backupPathForOpen, originalPathForOpen, ec);
    if (ec) {
        // try making a copy instead, maybe backup dir is on another partition
        std::filesystem::copy_file(backupPathForOpen, originalPathForOpen, ec);
    }
    if (ec) {
        throw std::ios_base::failure("Unable to restore original file from backup file \"" % backupPath % "\" after failure: " + ec.message());
    }
}
 
void createBackupFile(const std::string &backupDir, const std::string &originalPath, std::string &backupPath, NativeFileStream &originalStream,
    NativeFileStream &backupStream)
{
    // determine dirs
    const auto backupDirRelative = std::filesystem::path(makeNativePath(backupDir)).is_relative();
    const auto originalDir = backupDirRelative ? BasicFileInfo::containingDirectory(originalPath) : string();
 
    // determine the backup path
    auto ec = std::error_code();
    for (unsigned int i = 0;; ++i) {
        if (backupDir.empty()) {
            if (i) {
                backupPath = originalPath % '.' % i + ".bak";
            } else {
                backupPath = originalPath + ".bak";
            }
        } else {
            const auto fileName(BasicFileInfo::fileName(originalPath, i));
            if (i) {
                const auto ext(BasicFileInfo::extension(originalPath));
                if (backupDirRelative) {
                    backupPath = originalDir % '/' % backupDir % '/' % fileName % '.' % i + ext;
                } else {
                    backupPath = backupDir % '/' % fileName % '.' % i + ext;
                }
            } else {
                if (backupDirRelative) {
                    backupPath = originalDir % '/' % backupDir % '/' + fileName;
                } else {
                    backupPath = backupDir % '/' + fileName;
                }
            }
        }
 
        // test whether the backup path is still unused; otherwise continue loop
        if (!std::filesystem::exists(makeNativePath(BasicFileInfo::pathForOpen(backupPath)), ec)) {
            break;
        }
    }
 
    // ensure original file is closed
    if (originalStream.is_open()) {
        originalStream.close();
    }
 
    // rename original file
    const auto u8originalPath = std::filesystem::path(makeNativePath(originalPath));
    const auto backupPathForOpen = std::filesystem::path(makeNativePath(BasicFileInfo::pathForOpen(backupPath)));
    std::filesystem::rename(u8originalPath, backupPathForOpen, ec);
    if (ec) {
        // try making a copy instead, maybe backup dir is on another partition
        std::filesystem::copy_file(u8originalPath, backupPathForOpen, ec);
    }
    if (ec) {
        throw std::ios_base::failure(argsToString("Unable to create backup file \"", BasicFileInfo::pathForOpen(backupPath), "\" of \"", originalPath,
            "\" before rewriting it: " + ec.message()));
    }
 
    // manage streams
    try {
        // ensure there is no file associated with the originalStream object
        if (originalStream.is_open()) {
            originalStream.close();
        }
        // ensure there is no file associated with the backupStream object
        if (backupStream.is_open()) {
            backupStream.close();
        }
        // open backup stream
        backupStream.exceptions(ios_base::failbit | ios_base::badbit);
        backupStream.open(BasicFileInfo::pathForOpen(backupPath).data(), ios_base::in | ios_base::binary);
    } catch (const std::ios_base::failure &failure) {
        // try to restore the previous state in the error case
        try {
            restoreOriginalFileFromBackupFile(originalPath, backupPath, originalStream, backupStream);
        } catch (const std::ios_base::failure &) {
            throw std::ios_base::failure("Unable to restore original file from backup file \"" % backupPath % "\" after failure: " + failure.what());
        }
        throw std::ios_base::failure(argsToString("Unable to open backup file: ", failure.what()));
    }
}
 
void createBackupFileCanonical(const std::string &backupDir, std::string &originalPath, std::string &backupPath,
    CppUtilities::NativeFileStream &originalStream, CppUtilities::NativeFileStream &backupStream)
{
    auto ec = std::error_code();
    if (const auto canonicalPath = std::filesystem::canonical(makeNativePath(BasicFileInfo::pathForOpen(originalPath)), ec); !ec) {
        originalPath = canonicalPath.string();
    } else {
        throw std::ios_base::failure("Unable to canonicalize path of original file before rewriting it: " + ec.message());
    }
    createBackupFile(backupDir, originalPath, backupPath, originalStream, backupStream);
}
 
void handleFailureAfterFileModified(MediaFileInfo &fileInfo, const std::string &backupPath, NativeFileStream &outputStream,
    NativeFileStream &backupStream, Diagnostics &diag, const std::string &context)
{
    handleFailureAfterFileModifiedCanonical(fileInfo, fileInfo.path(), backupPath, outputStream, backupStream, diag, context);
}
 
void handleFailureAfterFileModifiedCanonical(MediaFileInfo &fileInfo, const std::string &originalPath, const std::string &backupPath,
    CppUtilities::NativeFileStream &outputStream, CppUtilities::NativeFileStream &backupStream, Diagnostics &diag, const std::string &context)
{
    // reset the associated container in any case
    if (fileInfo.container()) {
        fileInfo.container()->reset();
    }
 
    // re-throw the current exception
    try {
        throw;
    } catch (const OperationAbortedException &) {
        if (!backupPath.empty()) {
            // a temp/backup file has been created -> restore original file
            diag.emplace_back(DiagLevel::Information, "Rewriting the file to apply changed tag information has been aborted.", context);
            try {
                restoreOriginalFileFromBackupFile(originalPath, backupPath, outputStream, backupStream);
                diag.emplace_back(DiagLevel::Warning, "The original file has been restored.", context);
            } catch (const std::ios_base::failure &failure) {
                diag.emplace_back(DiagLevel::Critical, argsToString("The original file could not be restored: ", failure.what()), context);
            }
        } else {
            diag.emplace_back(DiagLevel::Information, "Applying new tag information has been aborted.", context);
        }
        throw;
 
    } catch (const Failure &) {
        if (!backupPath.empty()) {
            // a temp/backup file has been created -> restore original file
            diag.emplace_back(DiagLevel::Critical, "Rewriting the file to apply changed tag information failed.", context);
            try {
                restoreOriginalFileFromBackupFile(originalPath, backupPath, outputStream, backupStream);
                diag.emplace_back(DiagLevel::Warning, "The original file has been restored.", context);
            } catch (const std::ios_base::failure &failure) {
                diag.emplace_back(DiagLevel::Critical, argsToString("The original file could not be restored: ", failure.what()), context);
            }
        } else {
            diag.emplace_back(DiagLevel::Critical, "Applying new tag information failed.", context);
        }
        throw;
 
    } catch (const std::ios_base::failure &) {
        if (!backupPath.empty()) {
            // a temp/backup file has been created -> restore original file
            diag.emplace_back(DiagLevel::Critical, "An IO error occurred when rewriting the file to apply changed tag information.", context);
            try {
                restoreOriginalFileFromBackupFile(originalPath, backupPath, outputStream, backupStream);
                diag.emplace_back(DiagLevel::Warning, "The original file has been restored.", context);
            } catch (const std::ios_base::failure &failure) {
                diag.emplace_back(DiagLevel::Critical, argsToString("The original file could not be restored: ", failure.what()), context);
            }
        } else {
            diag.emplace_back(DiagLevel::Critical, "An IO error occurred when applying tag information.", context);
        }
        throw;
    }
}
 
} // namespace BackupHelper
 
} // namespace TagParser