inputHandler::davix::readerDavix Class Reference

#include <inputHandlerDavix.h>

Inheritance diagram for inputHandler::davix::readerDavix:

Collaboration diagram for inputHandler::davix::readerDavix:

Public Member Functions
	readerDavix (davixCommon &aHandler, const std::string &aPath, copyRequest::stateType &state, const genericStat &inititalStat)
	~readerDavix () noexcept(false) override
bool	readBlock (block &b) override
void	readBlockP (block &b, size_t bytesToRead, off_t offset) override
bool	parallelizable () const override
	tell if this handler is capable of parallel IO. Unsually not the case More...
void	checkUnchangedness () override
Public Member Functions inherited from davixIoCommon
	davixIoCommon (const std::string &aPath, davixCommon &aHandler)
std::unique_ptr< const genericStat >	getStat () override
Public Member Functions inherited from ioHandle
	ioHandle ()
virtual	~ioHandle () noexcept(false)
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 davixIoCommon
const std::string &	path
davixCommon &	handler
DAVIX_FD *	fd
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 16 of file inputHandlerDavix.h.

Constructor & Destructor Documentation

readerDavix()

inputHandler::davix::readerDavix::readerDavix	(	davixCommon &	aHandler,
		const std::string &	aPath,
		copyRequest::stateType &	state,
		const genericStat &	inititalStat
	)

Definition at line 60 of file inputHandlerDavix.cpp.

                                                                    :
        davixIoCommon(aPath, aHandler),
        reader(inititalStat) {
        errorReport report(__func__, "open", path);
        fd = handler.posix.open(&handler.params, path.c_str(), O_RDONLY, report);
        if (fd == nullptr) {
            if (report->getStatus() == Davix::StatusCode::FileNotFound) {
                state |= copyRequest::stateBitType::vanished;
            }
            report.throwUp();
        }
        blockSize = readInitialStat.blksize;
    }

References ioHandle::blockSize, davixIoCommon::fd, davixIoCommon::handler, davixCommon::params, davixIoCommon::path, davixCommon::posix, errorReport::throwUp(), and copyRequest::vanished.

Here is the call graph for this function:

~readerDavix()

inputHandler::davix::readerDavix::~readerDavix ( )

overridenoexcept

Definition at line 76 of file inputHandlerDavix.cpp.

                                                   {
        if (fd) {
            errorReport report(__func__, "close", path);
            if (handler.posix.close(fd, report) != 0) {
                if (isUnwinding()) {
                    errMsg::emit(errMsg::level::debug, errMsg::location(),
                                 path, "close during unwind ",
                                 report.getMessage());
                    return;
                }
                report.throwUp();
            }
        }
    }

References errMsg::debug, errMsg::emit(), errorReport::getMessage(), and errorReport::throwUp().

Here is the call graph for this function:

Member Function Documentation

checkUnchangedness()

void inputHandler::davix::readerDavix::checkUnchangedness ( )

override

Definition at line 158 of file inputHandlerDavix.cpp.

                                              {
    };

parallelizable()

bool inputHandler::davix::readerDavix::parallelizable ( ) const

overridevirtual

tell if this handler is capable of parallel IO. Unsually not the case

Reimplemented from ioHandle.

Definition at line 129 of file inputHandlerDavix.cpp.

                                                {
        return true;
    }

readBlock()

bool inputHandler::davix::readerDavix::readBlock ( block &  b )

override

Definition at line 92 of file inputHandlerDavix.cpp.

                                             {
        b.clear(totalBytesRead);
        bool lastblock = false;
        while (b.size() + blockSize <= b.max_size()) {
            readRateLimit.wait();
            errorReport report(__func__, "read", path);
            timerInst(read);
            auto bytes_read = handler.posix.read(fd, b.bufferAt(b.size()), blockSize, report);
            if (bytes_read < 0) {
                report.throwUp();
            }
            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;
            }
            readRateLimit.update(bytes_read);
            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 block::bufferAt(), block::bump_size(), block::clear(), block::max_size(), readRateLimit, block::size(), errorReport::throwUp(), timerInst, throttle::watch::update(), and throttle::watch::wait().

Here is the call graph for this function:

readBlockP()

void inputHandler::davix::readerDavix::readBlockP ( block &  b, size_t  bytesToRead, off_t  offset  )

override

Definition at line 133 of file inputHandlerDavix.cpp.

                                                                                {
        b.clear(offset);
        while (b.size() + blockSize <= b.max_size()) {
            errorReport report(__func__, "pread", path);
            timerInst(pread);
            auto bytes_read = handler.posix.pread64(fd, b.bufferAt(b.size()), blockSize, offset + b.size(),report);
            if (bytes_read < 0)
                report.throwUp();
            if (bytes_read == 0) {
                break;
            }
            b.bump_size(bytes_read);
            if (b.size() > bytesToRead) {
                throw delayAdvisingError(path + " has grown while reading");
            }
        }
        if (b.size() < bytesToRead) {
            throw delayAdvisingError(path + " has shrunk while reading "
                                     + std::to_string(bytesToRead)
                                     + " "
                                     + std::to_string(b.size()));
        }
    }

References block::bufferAt(), block::bump_size(), block::clear(), block::max_size(), block::size(), errorReport::throwUp(), and timerInst.

Here is the call graph for this function:

---

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

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