inputHandlerDcap.cpp

Go to the documentation of this file.

#include "inputHandlerDcap.h"
 
#include <memory>
 
#include "block.h"
#include "copyRequestTypes.h"
#include "ewmscp.h"
 
#include <errMsgQueue.h>
 
namespace inputHandler {
    decltype(dcap::factory) dcap::factory("dcap");
    std::unique_ptr<base::reader> dcap::newReader(const std::string& aPath,
            copyRequest::stateType &state,
            const genericStat& inititalStat) {
        return std::unique_ptr<base::reader>(new readerDcap(aPath,
                                             state,
                                             inititalStat));
    }
 
 
    dcap::readerDcap::readerDcap(const std::string& aPath,
                                 copyRequest::stateType &state,
                                 const genericStat&inititalStat):
        dcapIoCommon(aPath),
        reader(inititalStat) {
        dCapLock extraOptionLock;
        fd = dc_open(path.c_str(), O_RDONLY);
        if (fd == -1) {
            if (errno == ENOENT
                    || (errno == ENOTDIR && !S_ISDIR(readInitialStat.mode))) {
                state |= copyRequest::stateBitType::vanished;
            }
        }
        throwcall::dcap::badval(fd, -1, "can't open ", path, " for reading");
        blockSize = readInitialStat.blksize;
    }
 
    dcap::readerDcap::~readerDcap() {
        if (fd != -1) {
            dCapLock extraOptionLock;
            if (isUnwinding()) {
                if (dc_close(fd) != 0) {
                    errMsg::emit(errMsg::level::debug, errMsg::location(),
                                 path, "close during unwind ",
                                 dc_strerror(dc_errno));
                }
                return;
            }
            throwcall::dcap::good0(dc_close(fd), "can't close ", path, " after reading");
        }
    }
 
 
    bool dcap::readerDcap::readBlock(block& b) {
        b.clear(totalBytesRead);
        bool lastblock = false;
 
        while (b.size() + blockSize <= b.max_size()) {
            readRateLimit.wait();
            auto bytes_read = throwcall::dcap::badval(dc_read(fd, b.bufferAt(b.size()), blockSize),
                              -1, "read failed on ", path);
            readRateLimit.update(bytes_read);
            if (bytes_read == 0) {
                lastblock = true;
                if (totalBytesRead < readInitialStat.size) {
                    throw delayAdvisingError(path + " has shrunk while reading, (" +
                                             std::to_string(readInitialStat.size) +
                                             " -> " +
                                             std::to_string(totalBytesRead) +
                                             ")");
                }
                break;
            }
            totalBytesRead += bytes_read;
            if (totalBytesRead > readInitialStat.size) {
                throw delayAdvisingError(path + " has grown while reading, (" +
                                         std::to_string(readInitialStat.size) +
                                         " -> " +
                                         std::to_string(totalBytesRead) +
                                         ")");
            }
 
            b.bump_size(bytes_read);
        }
 
        return lastblock;
    }
 
 
    void dcap::readerDcap::checkUnchangedness() {
        struct dcapStat readFinalStatBuf;
        dCapLock extraOptionLock;
        throwcall::dcap::good0(dc_fstat(fd, &readFinalStatBuf), "can't stat path file ", path);
        genericStat readFinalStat(readFinalStatBuf, std::chrono::seconds(1));
        if (readFinalStat.size != readInitialStat.size) {
            throw delayAdvisingError("file size has changed (" +
                                     std::to_string(readInitialStat.size) +
                                     " -> " +
                                     std::to_string(readFinalStat.size) +
                                     ") during reading on " + path);
        }
 
        if (!readFinalStat.isSameMtimeAs(readInitialStat)) {
            throw delayAdvisingError("file " + path + " was modified (" +
                                     std::to_string(std::chrono::duration_cast<std::chrono::duration<double>>(readFinalStat.getMtime() - readInitialStat.getMtime()).count()) +
                                     "s different mtime) during reading");
        }
    }
    dcap::dcapDirectory::dcapDirectory(const std::string& aPath):
        Directory(dcapCommon::fixPathUrl(aPath)) {
        dCapLock extraOptionLock;
        dir = throwcall::dcap::badval(dc_opendir(path.c_str()), nullptr, "can't open directory ", path);
    }
    dcap::dcapDirectory::~dcapDirectory() noexcept(false) {
        dCapLock extraOptionLock;
        if (isUnwinding()) {
            if (dc_closedir(dir) != 0) {
                errMsg::emit(errMsg::level::debug, errMsg::location(),
                             path, "close directory during unwind ",
                             dc_strerror(dc_errno));
            }
        } else {
            throwcall::dcap::good0(dc_closedir(dir), "can't close directory ", path);
        }
    }
    std::unique_ptr<base::Directory::Entry> dcap::dcapDirectory::getNextEntry(bool ignoreMissing) {
        dCapLock extraOptionLock;
        while (auto entry = dc_readdir(dir)) {
            if (entry->d_name[entry->d_name[0] != '.' ? 0 : entry->d_name[1] != '.' ? 1 : 2] == '\0') {
                continue; // skip . .. and empty strings
            }
            struct dcapStat statbuf;
            auto entrypath(dcapCommon::fixPathUrl(path + "/" + entry->d_name));
            auto result = dc_stat(entrypath.c_str(), &statbuf);
            if (result != 0 && errno == ENOENT && ignoreMissing) {
                continue;
            }
            throwcall::dcap::good0(result, "can't stat ", entrypath);
            auto genStat = std::unique_ptr<const genericStat>(new genericStat(statbuf, std::chrono::seconds(1)));
            return std::unique_ptr<Entry>(new Entry(entry->d_name, genStat));
        }
        return nullptr;
    }
    std::unique_ptr<base::Directory> dcap::getDirectory(const std::string& path) {
        return std::unique_ptr<Directory>(new dcapDirectory(path));
    }
 
} //end namespace inputHandler