inputHandler::dcap::readerDcap Class Reference

#include <inputHandlerDcap.h>

Inheritance diagram for inputHandler::dcap::readerDcap:

Collaboration diagram for inputHandler::dcap::readerDcap:

Public Member Functions
	readerDcap (const std::string &aPath, copyRequest::stateType &state, const genericStat &inititalStat)
	~readerDcap () override
bool	readBlock (block &b) override
void	checkUnchangedness () override
Public Member Functions inherited from dcapIoCommon
	dcapIoCommon (const std::string &aPath)
std::unique_ptr< const genericStat >	getStat () override
Public Member Functions inherited from ioHandle
	ioHandle ()
virtual	~ioHandle () noexcept(false)
virtual bool	parallelizable () const
	tell if this handler is capable of parallel IO. Unsually not the case More...
virtual void	setXattr (const std::string &, const std::string &)
virtual std::string	getXattr (const std::string &)
	get one extended attribute value More...
virtual void	removeXattr (const std::string &)
virtual size_t	getBlockSize () const
virtual void	setBlockSize (size_t newSize)
virtual std::unique_ptr< attrDataType >	getAttrData (const outputHandler::base *)
	get attributes in the optimal way for setting with aOutputHandler More...
virtual std::unique_ptr< acl::list >	getAclData ()
	get acls More...

Additional Inherited Members
Protected Attributes inherited from dcapIoCommon
const std::string	path
int	fd = -1
Protected Attributes inherited from ioHandle
size_t	blockSize
	in bytes, block size to be used when reading or writing More...

Detailed Description

Definition at line 18 of file inputHandlerDcap.h.

Constructor & Destructor Documentation

readerDcap()

inputHandler::dcap::readerDcap::readerDcap	(	const std::string &	aPath,
		copyRequest::stateType &	state,
		const genericStat &	inititalStat
	)

Definition at line 22 of file inputHandlerDcap.cpp.

                                                                :
        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;
    }

References throwcall::dcap::badval(), ioHandle::blockSize, dcapIoCommon::fd, dcapIoCommon::path, and copyRequest::vanished.

Here is the call graph for this function:

~readerDcap()

inputHandler::dcap::readerDcap::~readerDcap ( )

override

Definition at line 39 of file inputHandlerDcap.cpp.

                                {
        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");
        }
    }

References errMsg::debug, errMsg::emit(), and throwcall::dcap::good0().

Here is the call graph for this function:

Member Function Documentation

checkUnchangedness()

void inputHandler::dcap::readerDcap::checkUnchangedness ( )

override

Definition at line 91 of file inputHandlerDcap.cpp.

                                            {
        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");
        }
    }

References dcapStat, genericStat::getMtime(), throwcall::dcap::good0(), genericStat::isSameMtimeAs(), and genericStat::size.

Here is the call graph for this function:

readBlock()

bool inputHandler::dcap::readerDcap::readBlock ( block &  b )

override

Definition at line 55 of file inputHandlerDcap.cpp.

                                           {
        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;
    }

References throwcall::dcap::badval(), block::bufferAt(), block::bump_size(), block::clear(), block::max_size(), readRateLimit, block::size(), throttle::watch::update(), and throttle::watch::wait().

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• src/inputHandlerDcap.h (v0.19-24-g0617ca1 with changes)
• src/inputHandlerDcap.cpp (v0.19-24-g0617ca1 with changes)