inputHandler::daosFs::readerDaosFs Class Reference

#include <inputHandlerDaosFs.h>

Inheritance diagram for inputHandler::daosFs::readerDaosFs:

Collaboration diagram for inputHandler::daosFs::readerDaosFs:

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

Additional Inherited Members
Protected Attributes inherited from daosFsIoCommon
const std::string &	path
dfs_obj_t *	obj
daosFsCommon &	handler
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 19 of file inputHandlerDaosFs.h.

Constructor & Destructor Documentation

readerDaosFs()

inputHandler::daosFs::readerDaosFs::readerDaosFs	(	const std::string &	aPath,
		copyRequest::stateType &	state,
		const genericStat &	inititalStat,
		daosFsCommon &	aHandler
	)

Definition at line 48 of file inputHandlerDaosFs.cpp.

                                                :
        daosFsIoCommon(aPath, aHandler),
        reader(inititalStat) {
        int retval;
        {
            timerInst(open);
            retval = dfs_open(handler.dfs, handler.getDirObj(path), path.c_str(), 0444, O_RDONLY,
                              0, readInitialStat.blksize, nullptr, &obj);
        }
        if (retval) {
            if (errno == ENOENT
                    || (errno == ENOTDIR && !S_ISDIR(readInitialStat.mode))) {
                state |= copyRequest::stateBitType::vanished;
            }
        }
        throwcall::good0(retval, "can't open ", path, " for reading");
        blockSize = readInitialStat.blksize;
    }

References ioHandle::blockSize, daosFsCommon::dfs, daosFsCommon::getDirObj(), throwcall::good0(), daosFsIoCommon::handler, daosFsIoCommon::obj, daosFsIoCommon::path, timerInst, and copyRequest::vanished.

Here is the call graph for this function:

~readerDaosFs()

inputHandler::daosFs::readerDaosFs::~readerDaosFs ( )

override

Definition at line 70 of file inputHandlerDaosFs.cpp.

                                      {
        if (obj) {
            if (isUnwinding()) {
                timerInst(release);
                if (dfs_release(obj) != 0) {
                    errMsg::emit(errMsg::level::debug, errMsg::location(),
                                 path, "release during unwind ",
                                 std::system_category().default_error_condition(errno).message());
                }
                return;
            }
            {
                timerInst(release);
                throwcall::good0(dfs_release(obj), "can't release ", path, " after reading");
            }
        }
    }

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

Here is the call graph for this function:

Member Function Documentation

checkUnchangedness()

void inputHandler::daosFs::readerDaosFs::checkUnchangedness ( )

override

Definition at line 171 of file inputHandlerDaosFs.cpp.

                                                {
        struct stat readFinalStatBuf;
        {
            timerInst(fstat);
            throwcall::good0(dfs_ostat(handler.dfs, obj, &readFinalStatBuf), "can't stat path file ", path);
        }
        genericStat readFinalStat(readFinalStatBuf, std::chrono::nanoseconds(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 genericStat::getMtime(), throwcall::good0(), genericStat::isSameMtimeAs(), genericStat::size, and timerInst.

Here is the call graph for this function:

parallelizable()

bool inputHandler::daosFs::readerDaosFs::parallelizable ( ) const

overridevirtual

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

Reimplemented from ioHandle.

Definition at line 91 of file inputHandlerDaosFs.cpp.

                                                  {
        return true;
    }

readBlock()

bool inputHandler::daosFs::readerDaosFs::readBlock ( block &  b )

override

Definition at line 94 of file inputHandlerDaosFs.cpp.

                                               {
        b.clear(totalBytesRead);
        bool lastblock = false;
 
        auto bytesToRead = b.max_size();
 
        while (b.size() + blockSize <= bytesToRead) {
            readRateLimit.wait();
            d_iov_t iov;
            iov.iov_buf =  b.bufferAt(b.size());
            iov.iov_buf_len = blockSize;
            d_sg_list_t sg_list;
            sg_list.sg_nr=1;
            sg_list.sg_iovs = &iov;
            timerInst(read);
            daos_size_t bytes_read;
            throwcall::good0(dfs_read(handler.dfs, obj, &sg_list, totalBytesRead, &bytes_read, nullptr),
                             "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 block::bufferAt(), block::bump_size(), block::clear(), throwcall::good0(), block::max_size(), readRateLimit, block::size(), timerInst, throttle::watch::update(), and throttle::watch::wait().

Here is the call graph for this function:

readBlockP()

void inputHandler::daosFs::readerDaosFs::readBlockP ( block &  b, size_t  bytesToRead, off_t  offset  )

override

Definition at line 140 of file inputHandlerDaosFs.cpp.

                                                                                  {
        b.clear(offset);
        while (b.size() + blockSize <= b.max_size()) {
            timerInst(pread);
            d_iov_t iov;
            iov.iov_buf =  b.bufferAt(b.size());
            iov.iov_buf_len = blockSize;
            d_sg_list_t sg_list;
            sg_list.sg_nr=1;
            sg_list.sg_iovs = &iov;
            timerInst(read);
            daos_size_t bytes_read;
            throwcall::good0(dfs_read(handler.dfs, obj, &sg_list, offset + b.size() , &bytes_read, nullptr),
                             "read failed on ", path);
            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(), throwcall::good0(), block::max_size(), block::size(), and timerInst.

Here is the call graph for this function:

---

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

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