outputHandlerDavix.cpp

Go to the documentation of this file.

#include "OptionsChrono.h"
#include "ewmscp.h"
#include "block.h"
#include "copyRequestTypes.h"
#include "outputHandlerDavix.h"
#include "throwcall.h"
#include "errMsgQueue.h"
#include <libgen.h>
 
namespace outputHandler {
    decltype(davix::factory) davix::factory("davix");
    std::unique_ptr<base::writer> davix::newWriter(const std::string& path,
            bool /*mightAppend*/,
            size_t /*sourceSize*/,
            size_t /*readBlockSize*/,
            copyRequest::stateType &state,
            bool noWrite,
            std::unique_ptr<ioHandle::attrDataType>,
            std::unique_ptr<acl::list>) {
        return std::unique_ptr<base::writer>(new writerDavix(*this, path,
                                             state, noWrite));
    }
 
 
    static davixConfigObject outputConfig("davixOut");
 
 
 
    davix::davix():
        davixCommon(outputConfig) {
    };
 
 
 
    void davix::ensureParentDirs(const std::string& path,
                                 const std::string& srcPath,
                                 inputHandler::base* InputHandler) {
        std::vector<std::remove_reference<decltype(path)>::type::value_type> disposable_buffer(path.c_str(), path.c_str() + path.size() + 1);
        std::string dir(dirname(disposable_buffer.data()));
        struct stat statbuf;
        errorReport report(__func__, "stat", dir);
        if (posix.stat(&params, dir, &statbuf, report) != 0) {
            if (report->getStatus() == Davix::StatusCode::FileNotFound) {
                ensureParentDirs(dir, srcPath, InputHandler);
                errorReport report2(__func__, "mkdir", dir);
                if (posix.mkdir(&params, dir, 0777u, report2) != 0) {
                    if (report2->getStatus() == Davix::StatusCode::FileExist) {
                        return; // we lost a race with another copy process...
                    }
                    report2.throwUp();
                }
            } else {
                report.throwUp();
            }
        } else if (! S_ISDIR(statbuf.st_mode)) {
            errMsg::emit(errMsg::level::info, errMsg::location(),
                         dir, "ensure parents",
                         "is not a directory (st_mode is ", statbuf.st_mode, ") but should be");
        }
    }
 
 
    void davix::remove(const std::string& path, copyRequest::stateType& state) {
        struct stat dsttat;
        {
            errorReport report(__func__, "stat", path);
            if (posix.stat(&params, path, &dsttat, report) != 0) {
                if (report->getStatus() == Davix::StatusCode::FileNotFound) {
                    state |= copyRequest::stateBitType::vanished;
                    return;
                }
                report.throwUp();
            }
        }
        if (S_ISDIR(dsttat.st_mode)) {
            errorReport report(__func__, "rmdir", path);
            if (posix.rmdir(nullptr, path, report) != 0) {
                if (report->getStatus() == Davix::StatusCode::FileNotFound) {
                    state |= copyRequest::stateBitType::vanished;
                    return;
                } else if (report->getStatus() == Davix::StatusCode::FileExist) {
                    state |= copyRequest::stateBitType::failed;
                    return;
                } else {
                    report.throwUp();
                }
            } else {
                state |= copyRequest::stateBitType::done;
                return;
            }
        } else {
            errorReport report(__func__, "unlink", path);
            if (posix.unlink(&params, path, report) != 0) {
                if (report->getStatus() == Davix::StatusCode::FileNotFound) {
                    state |= copyRequest::stateBitType::vanished;
                    return;
                }
                report.throwUp();
            }
            state |= copyRequest::stateBitType::done;
        }
    }
 
 
    bool davix::renameSimple(const std::string& fromPath,
                             const std::string& toPath) {
        {
            // rename chokes when target already exists, so remove it beforehand
            errorReport report(__func__, "unlink", toPath);
            if (posix.unlink(&params, toPath, report) != 0) {
                if (report->getStatus() != Davix::StatusCode::FileNotFound) {
                    report.throwUp();
                }
            }
        }
        {
            errorReport report(__func__, "rename", fromPath);
            if (posix.rename(&params, fromPath, toPath, report)) {
                if (report->getStatus() == Davix::StatusCode::FileNotFound) {
                    return false;
                }
                report.throwUp();
            }
        }
        return true;
    }
 
    base::renameRetvalType davix::rename(const std::string& /*fromPath*/,
                                         const std::unique_ptr<const genericStat>& /*readInitialStat*/,
                                         const std::string& /*toPath*/,
                                         copyRequest::stateType& /*state*/) {
        // we cannot be sure that the fromPath is up to date, always do a new copy
        return base::renameRetvalType::fileChanged;
    }
 
 
    davix::writerDavix::writerDavix(davix& aHandler,
                                    const std::string& aPath,
                                    copyRequest::stateType &state,
                                    bool noWrite):
        davixIoCommon(aPath, aHandler) {
        if (noWrite) {
            fd = nullptr;
        } else {
            auto openMode = O_CREAT | O_WRONLY;
            state.clear(copyRequest::stateBitType::append); // clear any old append sets, may be left over from former attempts
            errorReport report(__func__, "open", path);
            fd = handler.posix.open(&handler.params, path.c_str(), openMode, report);
            if (fd == nullptr) {
                report.throwUp();
            }
        }
    };
    void davix::writerDavix::closeAndRemoveBadCopy() {
        errorReport report(__func__, "close", path);
        if (handler.posix.close(fd, report) != 0) {
            errMsg::emit(errMsg::level::debug, errMsg::location(),
                         path, "close during unwind ",
                         report.getMessage());
        }
        errorReport report2(__func__, "unlink", path);
        errMsg::emit(errMsg::level::debug, errMsg::location(),
                     path, "unlink failed copy", "due to exception");
        if (handler.posix.unlink(&handler.params, path, report) != 0) {
            report2.throwUp();
        }
    };
    davix::writerDavix::~writerDavix() noexcept(false) {
        if (fd != nullptr) {
            if (isUnwinding()) {
                closeAndRemoveBadCopy();
                return;
            }
            errorReport report(__func__, "close", path);
            if (handler.posix.close(fd, report) != 0) {
                report.throwUp();
            }
        }
    };
 
 
    void davix::writerDavix::writeBlock(const block& b) {
        size_t bytes_writen_so_far = 0;
 
        while (bytes_writen_so_far < b.size()) {
            writeRateLimit.wait();
            auto count = b.size() - bytes_writen_so_far;
 
            if (b.isHole()) { // just write zeroes
                count = std::min({count, blockSize, block::nullBufferSize()});
            } else {
                count = std::min(count, blockSize);
            }
            errorReport report(__func__, "write", path);
            auto bytes_writen = handler.posix.write(fd, b.bufferAt(bytes_writen_so_far), count, report);
            if (bytes_writen < 0) {
                report.throwUp();
            }
 
            writeRateLimit.update(bytes_writen);
            bytes_writen_so_far += bytes_writen;
        }
    }
 
 
 
    void davix::writerDavix::doAttributePreservations(const genericStat& /*readInitialStat*/) {
        // not supportted
    }
 
    void davix::writerDavix::sync() {
        throw std::runtime_error("sync not supported");
    }
}; // end namespace outputHandler