tagparser/backuphelper.cpp

#include "./backuphelper.h"
#include "./mediafileinfo.h"

#include <c++utilities/conversion/stringconversion.h>
#include <c++utilities/conversion/stringbuilder.h>
#include <c++utilities/io/catchiofailure.h>

#ifdef PLATFORM_WINDOWS
# include <windows.h>
#else
# include <sys/stat.h>
#endif

#include <string>
#include <fstream>
#include <cstdio>
#include <stdexcept>

using namespace std;
using namespace ConversionUtilities;
using namespace IoUtilities;

namespace Media {

/*!
 * \namespace Media::BackupHelper
 * \brief Helps to create and restore backup files when rewriting
 *        files to apply changed tag information.
 *
 * Methods in this namespace are internally used eg. in implementations of AbstractContainer::internalMakeFile().
 */

namespace BackupHelper {

/*!
 * \brief Returns the directory used to store backup files.
 *
 * Setting this value allows creation of backup files in a custom location
 * instead of the directory of the file being modified.
 *
 * \todo Add this as member variable to MediaFileInfo to avoid global.
 */
string &backupDirectory()
{
    static string backupDir;
    return backupDir;
}

/*!
 * \brief Restores the original file from the specified backup file.
 * \param originalPath Specifies the path to the original file.
 * \param backupPath Specifies the path to the backup file.
 * \param originalStream Specifies a std::fstream instance for the original file.
 * \param backupStream Specifies a std::fstream instance for the backup file.
 *
 * This helper function is used by MediaFileInfo and container implementations
 * to restore the original file from the specified backup file in the case a Failure
 * or an IO error occurs. The specified streams will be closed if
 * currently open.
 *
 * If moving isn't possible (eg. \a originalPath and \a backupPath refer to different partitions) the backup
 * file will be restored by copying.
 *
 * \throws Throws std::ios_base::failure on failure.
 * \todo Implement callback for progress updates (copy).
 */
void restoreOriginalFileFromBackupFile(const std::string &originalPath, const std::string &backupPath, NativeFileStream &originalStream, NativeFileStream &backupStream)
{
    // ensure the orignal stream is closed
    if(originalStream.is_open()) {
        originalStream.close();
    }
    // check wether backup file actually exists and close the backup stream afterwards
    backupStream.exceptions(ios_base::goodbit);
    backupStream.close();
    backupStream.clear();
    backupStream.open(backupPath, ios_base::in | ios_base::binary);
    if(backupStream.is_open()) {
        backupStream.close();
    } else {
        throwIoFailure("Backup/temporary file has not been created.");
    }
    // remove original file and restore backup
    std::remove(originalPath.c_str());
    if(std::rename(backupPath.c_str(), originalPath.c_str())) {
        // can't rename/move the file (maybe backup dir on another partition) -> make a copy instead
        try {
            // need to open all streams again
            backupStream.exceptions(ios_base::failbit | ios_base::badbit);
            originalStream.exceptions(ios_base::failbit | ios_base::badbit);
            backupStream.open(backupPath, ios_base::in | ios_base::binary);
            originalStream.open(originalPath, ios_base::out | ios_base::binary);
            originalStream << backupStream.rdbuf();
            // TODO: callback for progress updates
        } catch(...) {
            catchIoFailure();
            throwIoFailure(("Unable to restore original file from backup file \"" % backupPath + "\" after failure.").data());
        }
    }
}

/*!
 * \brief Returns whether the specified \a path is relative.
 */
static bool isRelative(const std::string &path)
{
    return path.empty() || (path.front() != '/' && (path.size() < 2 || path[1] != ':'));
}

/*!
 * \brief Creates a backup file for the specified file.
 * \param originalPath Specifies the path of the file to be backuped.
 * \param backupPath Contains the path of the created backup file when this function returns.
 * \param originalStream Specifies a std::fstream for the original file.
 * \param backupStream Specifies a std::fstream for creating the backup file.
 *
 * This helper function is used by MediaFileInfo and container implementations to create a backup file
 * when applying changes. The specified \a backupPath is set to the path of the created backup file.
 * The specified \a backupStream will be closed if currently open. Then it is
 * used to open the backup file using the flags ios_base::in and ios_base::binary.
 *
 * The specified \a originalStream is closed before performing the move operation.
 *
 * If moving isn't possible (eg. \a originalPath and \a backupPath refer to different partitions) the backup
 * file will be created by copying.
 *
 * The original file can now be rewritten to apply changes. When this operation fails
 * the created backup file can be restored using restoreOriginalFileFromBackupFile().
 *
 * \throws Throws std::ios_base::failure on failure.
 * \todo Implement callback for progress updates (copy).
 */
void createBackupFile(const std::string &originalPath, std::string &backupPath, NativeFileStream &originalStream, NativeFileStream &backupStream)
{
    // determine dirs
    const auto &backupDir(backupDirectory());
    const auto backupDirRelative(isRelative(backupDir));
    const auto originalDir(backupDirRelative ? BasicFileInfo::containingDirectory(originalPath) : string());

    // determine the backup path
    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
#ifdef PLATFORM_WINDOWS
        if(GetFileAttributes(backupPath.c_str()) == INVALID_FILE_ATTRIBUTES) {
#else
        struct stat backupStat;
        if(stat(backupPath.c_str(), &backupStat)) {
#endif
            break;
        }
    }

    // ensure original file is closed
    if(originalStream.is_open()) {
        originalStream.close();
    }

    // rename original file
    if(std::rename(originalPath.c_str(), backupPath.c_str())) {
        // can't rename/move the file (maybe backup dir on another partition) -> make a copy instead
        try {
            backupStream.exceptions(ios_base::failbit | ios_base::badbit);
            originalStream.exceptions(ios_base::failbit | ios_base::badbit);
            // ensure backupStream is opened as write-only
            if(backupStream.is_open()) {
                backupStream.close();
            }
            backupStream.open(backupPath, ios_base::out | ios_base::binary);
            // ensure originalStream is opened with read permissions
            originalStream.open(originalPath, ios_base::in | ios_base::binary);
            // do the actual copying
            backupStream << originalStream.rdbuf();
            // streams are closed in the next try-block
            // TODO: callback for progress updates
        } catch(...) {
            catchIoFailure();
            throwIoFailure("Unable to rename original file before rewriting it.");
        }
    }

    // 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(backupPath, ios_base::in | ios_base::binary);
    } catch(...) {
        catchIoFailure();
        // can't open the new file
        // -> try to re-rename backup file in the error case to restore previous state
        if(std::rename(backupPath.c_str(), originalPath.c_str())) {
            throwIoFailure(("Unable to restore original file from backup file \"" % backupPath + "\" after failure.").data());
        } else {
            throwIoFailure("Unable to open backup file.");
        }
    }
}

/*!
 * \brief Handles a failure/abort which occured after the file has been modified.
 *
 * - Restores the backup file using restoreOriginalFileFromBackupFile() if one has been created.
 * - Adds appropriate notifications to the specified \a fileInfo.
 * - Re-throws the exception.
 *
 * \remarks Must only be called when an exception derived from Failure or ios_base::failure
 *          has been catched; this method uses the "exception dispatcher" idiom.
 *
 * \param fileInfo Specifies the MediaFileInfo instace which has been modified.
 * \param backupPath Specifies the path of the backup file; might be empty if none has been created.
 * \param outputStream Specifies the stream used to write the output file. This is usually just the stream
 *                     of \a fileInfo, but is specified here explicitly for higher flexibility.
 * \param backupStream Specifies the stream assembled using createBackupFile(); might be a default fstream if
 *                     no backup file has been created.
 * \param context      Specifies the context used to add notifications.
 */
void handleFailureAfterFileModified(MediaFileInfo &fileInfo, const std::string &backupPath, NativeFileStream &outputStream, NativeFileStream &backupStream, 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
            fileInfo.addNotification(NotificationType::Information, "Rewriting the file to apply changed tag information has been aborted.", context);
            try {
                restoreOriginalFileFromBackupFile(fileInfo.path(), backupPath, outputStream, backupStream);
                fileInfo.addNotification(NotificationType::Information, "The original file has been restored.", context);
            } catch(...) {
                fileInfo.addNotification(NotificationType::Critical, catchIoFailure(), context);
            }
        } else {
            fileInfo.addNotification(NotificationType::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
            fileInfo.addNotification(NotificationType::Critical, "Rewriting the file to apply changed tag information failed.", context);
            try {
                restoreOriginalFileFromBackupFile(fileInfo.path(), backupPath, outputStream, backupStream);
                fileInfo.addNotification(NotificationType::Information, "The original file has been restored.", context);
            } catch(...) {
                fileInfo.addNotification(NotificationType::Critical, catchIoFailure(), context);
            }
        } else {
            fileInfo.addNotification(NotificationType::Critical, "Applying new tag information failed.", context);
        }
        throw;

    } catch(...) {
        const char *what = catchIoFailure();
        if(!backupPath.empty()) {
            // a temp/backup file has been created -> restore original file
            fileInfo.addNotification(NotificationType::Critical, "An IO error occured when rewriting the file to apply changed tag information.", context);
            try {
                restoreOriginalFileFromBackupFile(fileInfo.path(), backupPath, outputStream, backupStream);
                fileInfo.addNotification(NotificationType::Information, "The original file has been restored.", context);
            } catch(...) {
                fileInfo.addNotification(NotificationType::Critical, catchIoFailure(), context);
            }
        } else {
            fileInfo.addNotification(NotificationType::Critical, "An IO error occured when applying tag information.", context);
        }
        throwIoFailure(what);
    }
}

}

}