outputHandlerDcap.cpp

Go to the documentation of this file.

#include "outputHandlerDcap.h"
 
#include "ewmscp.h"
#include "block.h"
#include "copyRequest.h"
#include "errMsgQueue.h"
#include <libgen.h>
#include <algorithm>
 
 
namespace outputHandler {
    decltype(dcap::factory) dcap::factory("dcap");
    std::unique_ptr<base::writer> dcap::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> aclData) {
        return std::unique_ptr<base::writer>(new writerDcap(path, mightAppend,
                                             sourceSize, readBlockSize,
                                             state, noWrite,
                                             std::move(aclData)));
    }
 
    dcap::dcap() {
        if (copyRequest::base::setAttributesAfterClose == false) {
            errMsg::emit(errMsg::level::info, errMsg::location(),
                         "--", "dcap output handler",
                         "setting setAttributesAfterClose automatically");
            copyRequest::base::setAttributesAfterClose = true;
        }
    }
 
    void dcap::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 dcapStat statbuf;
        int statResult;
        {
            dCapLock extraOptionLock;
            statResult = dc_stat(fixPathUrl(dir).c_str(), &statbuf);
        }
        if (statResult) {
            if (errno == ENOENT) {
                auto srcDir = srcPath.substr(0, srcPath.find_last_of('/'));
                while (srcDir.back() == '/') {
                    srcDir.pop_back();
                }
                ensureParentDirs(dir, srcDir, InputHandler);
                dCapLock extraOptionLock;
                if (preserve.acls) {
                    auto aclData = InputHandler->getAclData(srcDir);
                    if (aclData) {
                        setAclData(*aclData, true);
                    }
                }
                auto result = dc_mkdir(fixPathUrl(dir).c_str(), 0777u);
 
                if (result != 0 && errno == EEXIST) {
                    return; // we lost a race with another copy process...
                }
 
                throwcall::dcap::good0(result, "can't create directory ", dir);
 
                if (gid != -1 || uid != -1) {
                    throwcall::dcap::good0(dc_chown(fixPathUrl(dir).c_str(), uid, gid), "can't set owner/group (", uid, ",", gid, ") on ", dir);
                }
            }
        } 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 dcap::remove(const std::string& path, copyRequest::stateType& state) {
        dCapLock extraOptionLock;
        struct dcapStat dsttat;
        {
            auto retval = dc_lstat(fixPathUrl(path).c_str(), &dsttat);
 
            if (retval && errno == ENOENT) {
                state |= copyRequest::stateBitType::vanished;
                return;
            }
        }
        if (S_ISDIR(dsttat.st_mode)) {
            auto retval = dc_rmdir(fixPathUrl(path).c_str());
            if (retval) {
                switch (errno) {
                    case ENOENT:
                        state |= copyRequest::stateBitType::vanished;
                        return;
                    case ENOTEMPTY:
                    case EEXIST: // POSIX.1 allows this also
                        errMsg::emit(errMsg::level::info, errMsg::location(),
                                     path, "remove", "directory not empty but should be removed");
                        state |= copyRequest::stateBitType::failed;
                        return;
                }
                throwcall::dcap::good0(retval, "can't reemove directory ", path);
            } else {
                state |= copyRequest::stateBitType::done;
                return;
            }
        } else {
            auto retval = dc_unlink(fixPathUrl(path).c_str());
 
            if (retval && errno == ENOENT) {
                state |= copyRequest::stateBitType::vanished;
            } else {
                throwcall::dcap::good0(retval, "can't unlink ", path);
            }
            state |= copyRequest::stateBitType::done;
        }
    }
 
 
    bool dcap::renameSimple(const std::string& fromPath,
                            const std::string& toPath) {
        dCapLock extraOptionLock;
        auto retval = dc_rename(fromPath.c_str(), toPath.c_str());
        //find out proper errno
        //      if (retval && (errno == ENOENT || errno == ENOTDIR)) {
        //      return false;
        //}
        throwcall::dcap::good0(retval, "can't rename '", fromPath, "' to '", toPath, "'");
        return true;
    }
 
    base::renameRetvalType dcap::rename(const std::string& fromPath,
                                        const std::unique_ptr<const genericStat>& readInitialStat,
                                        const std::string& toPath,
                                        copyRequest::stateType& state) {
        dCapLock extraOptionLock;
        struct dcapStat fromPathStatBuf;
        auto statRetVal = dc_stat(fixPathUrl(fromPath).c_str(), &fromPathStatBuf);
        if (statRetVal && (errno == ENOENT || errno == ENOTDIR)) {
            if (readInitialStat && readInitialStat->isDir()) { // no need to act, dirs are created on the fly
                state |= copyRequest::stateBitType::ignore;
                return base::renameRetvalType::ok;
            }
            return base::renameRetvalType::fileVanished;
        } else if (statRetVal) { // curious error
            throwcall::dcap::good0(statRetVal, "can't stat '", fromPath, "'");
            return base::renameRetvalType::cantHappen; // never reached
        }
        genericStat fromPathStat(fromPathStatBuf, std::chrono::seconds(1));
        if (! readInitialStat || (
                    ! readInitialStat->isDir() &&
                    (fromPathStat.size != readInitialStat->size
                     || !fromPathStat.isSameMtimeAs(*readInitialStat)))) {
            // the copy on fromPath is not up to date, create a new copy
            errMsg::emit(errMsg::level::info, errMsg::location(),
                         fromPath, "move",
                         "file (", toPath, ") changed unexpectedly, doing fresh copy");
            return base::renameRetvalType::fileChanged;
        } else { // try to move the existing copy
            auto retval = dc_rename(fixPathUrl(fromPath).c_str(), fixPathUrl(toPath).c_str());
 
            if (retval && (errno == ENOENT || errno == ENOTDIR)) {
                if (readInitialStat->isDir()) { // no need to act, dirs are created on the fly
                    state |= copyRequest::stateBitType::ignore;
                    return base::renameRetvalType::ok;
                }
                errMsg::emit(errMsg::level::info, errMsg::location(),
                             fromPath, "move",
                             "vanished unexpectedly, doing fresh copy");
                // file was probably not copied yet, try to copy it from the move target
                return base::renameRetvalType::fileVanished;
            } else {
                throwcall::dcap::good0(retval, "can't rename '", fromPath, "' to '", toPath, "'");
                state |= copyRequest::stateBitType::done;
                return base::renameRetvalType::ok;
            }
        }
        return base::renameRetvalType::cantHappen;
    }
 
 
 
    void dcap::setAclData(const acl::list& aclData, bool isDir) {
        if (aclData.entries.empty()) {
            return;
        }
        bool needSpace = false;
        std::string result(" -acl=\"");
        for (const auto& entry : aclData.entries) {
            if (needSpace) {
                result += " ";
            }
            needSpace = true;
            result += entry.isAllowedType() ? "A:" : "D:";
            result += entry.isFlagSet(acl::list::entryType::flagsType::identifier_group) &&
                      ! entry.isFlagSet(acl::list::entryType::flagsType::special_who)
                      ? "g:" : ":";
            if (entry.isFlagSet(acl::list::entryType::flagsType::special_who)) {
                switch (entry.e_id) {
                    case acl::list::entryType::specialIdType::owner_special_id:
                        result += "OWNER@:";
                        break;
                    case acl::list::entryType::specialIdType::group_special_id:
                        result += "GROUP@:";
                        break;
                    case acl::list::entryType::specialIdType::everyone_special_id:
                        result += "EVERYONE@:";
                        break;
                    default:
                        throw std::runtime_error("illegal special id");
                }
            } else {
                result += std::to_string(entry.e_id);
                result += ":";
            }
            for (const auto& item : acl::list::entryType::aclMaskBits) {
                auto mask = entry._mask;
                if (isDir) {
                    mask.clear(acl::list::entryType::maskType::delete_child);
                }
                if (mask & item.first) {
                    result += item.second;
                }
            }
        }
        result += "\"";
        dc_setExtraOption(const_cast<char*>(result.c_str())); // ugly const cast due to bad dCap interface
 
    };
 
 
 
 
 
    decltype(dcap::writerDcap::unsafeWrite) dcap::writerDcap::unsafeWrite('\0', "dCapUnsafeWrite",
            "enable unsafe write mode, i.e. check only at close()");
    decltype(dcap::writerDcap::noChecksum) dcap::writerDcap::noChecksum('\0', "dCapNoChecksum",
            "disable dcap-internal adler32 checksum");
 
 
    dcap::writerDcap::writerDcap(const std::string& aPath,
                                 bool /* mightAppend */,
                                 size_t sourceSize,
                                 size_t /*readBlockSize*/,
                                 copyRequest::stateType &state,
                                 bool noWrite,
                                 std::unique_ptr<acl::list> aclData):
        dcapIoCommon(aPath) {
        blockSize = 16 * 1024 * 1024;
        if (noWrite) {
            fd = -1;
        } else {
            dCapLock extraOptionLock;
            std::string options("-alloc-size=");
            options += std::to_string(sourceSize);
            dc_setExtraOption(const_cast<char*>(options.c_str())); // const cast to work around broken interface
            if (aclData) {
                setAclData(*aclData);
            }
            auto openMode = O_CREAT | O_TRUNC | O_WRONLY;
            state.clear(copyRequest::stateBitType::append); // clear any old append sets, may be left over from former attempts
            // No appends on dcache, it's a WORM system
            fd = throwcall::dcap::badval(dc_open(path.c_str(), openMode, S_IWUSR | S_IRUSR),
                                         -1, "can't open ", path, " for writing");
            if (unsafeWrite) {
                dc_unsafeWrite(fd);
            }
            if (noChecksum) {
                dc_noCheckSum(fd);
            }
        }
    };
    void dcap::writerDcap::closeAndRemoveBadCopy() {
        if (dc_close(fd) != 0) {
            errMsg::emit(errMsg::level::debug, errMsg::location(),
                         path, "close during unwind ",
                         dc_strerror(dc_errno));
        }
        errMsg::emit(errMsg::level::debug, errMsg::location(),
                     path, "unlink failed copy", "due to exception");
        if (dc_unlink(path.c_str()) != 0) {
            errMsg::emit(errMsg::level::err, errMsg::location(),
                         path, "can't remove bad copy ",
                         dc_strerror(dc_errno));
        }
    };
 
    dcap::writerDcap::~writerDcap() noexcept(false) {
        if (fd != -1) {
            dCapLock extraOptionLock;
            if (isUnwinding()) {
                closeAndRemoveBadCopy();
                return;
            }
            throwcall::dcap::good0(dc_close(fd), "can't close ", path);
        }
    };
 
 
    void dcap::writerDcap::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);
            }
            auto bytes_writen = throwcall::dcap::badval(dc_write(fd, b.bufferAt(bytes_writen_so_far), count),
                                -1, "write failed on ", path);
            if (bytes_writen == 0) {
                throw std::runtime_error("wrote 0 bytes for " + path);
            }
            writeRateLimit.update(bytes_writen);
            bytes_writen_so_far += bytes_writen;
        }
    }
 
    void dcap::writerDcap::doAttributePreservations(const genericStat& /*readInitialStat*/) {
        throw unimplementedActionError("for dCap doAttributePreservations must be used with setAttributesAfterClose");
    }
 
    void dcap::doAttributePreservations(const std::string& path,
                                        const genericStat& stat) {
        if (preserve.timestamps) { // for mtime we must use a parallel nfs mount, there is no function in the dcap lib.
            struct timespec times[2];
            times[0].tv_nsec = UTIME_OMIT; // leave atime unchanged
            stat.getMtime(times[1]);
            auto serverStart = path.find("://");
            if (serverStart == std::string::npos) {
                throw std::runtime_error(path + " contains no \"://\"");
            }
            auto realPathStart = path.find("/", serverStart + 3);
            if (realPathStart == std::string::npos) {
                throw std::runtime_error(path + " contains no path after server part");
            }
            throwcall::good0(utimensat(0, path.c_str() + realPathStart,
                                       times, 0),
                             "can't set mtime on ", path.c_str() + realPathStart);
        }
        dCapLock extraOptionLock;
        if (preserve.mode) {
            throwcall::dcap::good0(dc_chmod(path.c_str(), stat.mode), "can't set mode of ", path);
        } else {
            auto oldmask = umask(0);
            auto retval = dc_chmod(path.c_str(), modeBits & ~oldmask);
            if (retval != 0) {
                errMsg::emit(errMsg::level::notice, errMsg::location(),
                             path, "chmod", "can't set mode ", dc_errno, " (", dc_strerror(dc_errno), ") ");
            }
            //throwcall::dcap::good0(dc_chmod(path.c_str(), modeBits & ~oldmask), "can't set mode of ", path);
            umask(oldmask);
        }
 
        if (gid != -1 || uid != -1) {
            throwcall::dcap::good0(dc_chown(path.c_str(), uid, gid), "can't set owner/group (", uid, ",", gid, ") of ", path);
        } else if (preserve.ownership) {
            throwcall::dcap::good0(dc_chown(path.c_str(), stat.ownerUid, stat.ownerGid),
                                   "can't set owner/group (", stat.ownerUid, ",", stat.ownerGid, ") of ",
                                   path);
        }
    }
 
 
    void dcap::writerDcap::sync() {
        throwcall::dcap::good0(dc_fsync(fd), "can't sync ", path);
    }
}; // end namespace outputHandler