outputHandler::daosFs::writerDaosFs Class Reference

#include <outputHandlerDaosFs.h>

Inheritance diagram for outputHandler::daosFs::writerDaosFs:

Collaboration diagram for outputHandler::daosFs::writerDaosFs:

Public Member Functions
	writerDaosFs (const std::string &aPath, bool mightAppend, size_t sourceSize, size_t readBlockSize, copyRequest::stateType &state, bool noWrite, std::unique_ptr< ioHandle::attrDataType > aAttrData, std::unique_ptr< acl::list > aAclData, daosFs &aHandler)
	writerDaosFs (std::string &aPath, bool noWrite, std::unique_ptr< ioHandle::attrDataType > aAttrData, std::unique_ptr< acl::list > aAclData, daosFs &aHandler)
void	closeAndRemoveBadCopy () override
	~writerDaosFs () noexcept(false) override
void	seek (size_t position) override
bool	parallelizable () const override
	tell if this handler is capable of parallel IO. Unsually not the case More...
size_t	getSize () const override
void	writeBlock (const block &b) override
void	writeBlockP (const block &b) override
void	doAttributePreservations (const genericStat &readInitialStat) override
void	sync () 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...

Protected Attributes
struct stat	writeInitialStat
std::unique_ptr< ioHandle::attrDataType >	attrData
std::unique_ptr< acl::list >	aclData
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 13 of file outputHandlerDaosFs.h.

Constructor & Destructor Documentation

writerDaosFs() [1/2]

outputHandler::daosFs::writerDaosFs::writerDaosFs	(	const std::string &	aPath,
		bool	mightAppend,
		size_t	sourceSize,
		size_t	readBlockSize,
		copyRequest::stateType &	state,
		bool	noWrite,
		std::unique_ptr< ioHandle::attrDataType >	aAttrData,
		std::unique_ptr< acl::list >	aAclData,
		daosFs &	aHandler
	)

Definition at line 229 of file outputHandlerDaosFs.cpp.

                                                        :
        daosFsIoCommon(aPath, aHandler),
        attrData(std::move(aAttrData)),
        aclData(std::move(aAclData)) {
        bool haveWriteStat = false;
        if (noWrite) {
            obj = nullptr;
            blockSize = 4096;
        } else {
            auto openMode = O_CREAT | O_TRUNC | O_WRONLY;
            state.clear(copyRequest::stateBitType::append); // clear any old append bits, may be left over from former attempts
            timerInstTO(open,slownessThreshold,path);
            fd = throwcall::badval(open(path.c_str(), openMode, S_IWUSR),
                                   -1, "can't open ", path, " for writing");
            if (!haveWriteStat) {
                throwcall::good0(fstat(fd, &writeInitialStat), "can't stat destination file ", path);
            }
            blockSize = writeInitialStat.st_blksize;
            throwcall::good0(posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL),
                             "can't advise ", path, " as sequential");
            throwcall::good0(posix_fadvise(fd, 0, 0, POSIX_FADV_NOREUSE),
                             "can't advise ", path, " as use only once");
        }
    };

References copyRequest::append, throwcall::badval(), ioHandle::blockSize, enumAsBitmask< T >::clear(), throwcall::good0(), daosFsIoCommon::obj, daosFsIoCommon::path, outputHandler::slownessThreshold, timerInstTO, and writeInitialStat.

Here is the call graph for this function:

writerDaosFs() [2/2]

outputHandler::daosFs::writerDaosFs::writerDaosFs	(	std::string &	aPath,
		bool	noWrite,
		std::unique_ptr< ioHandle::attrDataType >	aAttrData,
		std::unique_ptr< acl::list >	aAclData,
		daosFs &	aHandler
	)

~writerDaosFs()

outputHandler::daosFs::writerDaosFs::~writerDaosFs ( )

overridenoexcept

Definition at line 308 of file outputHandlerDaosFs.cpp.

                                                      {
        if (fd != -1) {
            if (isUnwinding()) {
                closeAndRemoveBadCopy();
                return;
            } else {
                if (attrData) {
                    try {
                        attrData->set(this);
                    } catch (const std::exception& e) {
                        errMsg::emit(errMsg::level::debug, errMsg::location(),
                                     path, "set attr at close ",
                                     e.what());
                        closeAndRemoveBadCopy();
                        throw;
                    }
                }
                timerInstTO(close,slownessThreshold,path);
                throwcall::good0(close(fd), "can't close ", path);
            }
        }
    };

References errMsg::debug, errMsg::emit(), throwcall::good0(), outputHandler::slownessThreshold, and timerInstTO.

Here is the call graph for this function:

Member Function Documentation

closeAndRemoveBadCopy()

void outputHandler::daosFs::writerDaosFs::closeAndRemoveBadCopy ( )

override

Definition at line 292 of file outputHandlerDaosFs.cpp.

                                                   {
        if (close(fd) != 0) {
            errMsg::emit(errMsg::level::debug, errMsg::location(),
                         path, "close during unwind ",
                         std::system_category().default_error_condition(errno).message());
        }
        errMsg::emit(errMsg::level::debug, errMsg::location(),
                     path, "unlink failed copy", "due to exception");
        auto retval = unlink(path.c_str());
        if (retval && errno != ENOENT) {
            errMsg::emit(errMsg::level::err, errMsg::location(),
                         path, "can't remove bad copy ",
                         std::system_category().default_error_condition(errno).message());
        }
    }

References errMsg::debug, errMsg::emit(), and errMsg::err.

Here is the call graph for this function:

doAttributePreservations()

void outputHandler::daosFs::writerDaosFs::doAttributePreservations ( const genericStat &  readInitialStat )

override

Definition at line 395 of file outputHandlerDaosFs.cpp.

                                                                                        {
        if (preserve.timestamps) {
            struct timespec times[2];
            readInitialStat.getAtime(times[0]);
            readInitialStat.getMtime(times[1]);
            timerInst(futimens);
            throwcall::good0(futimens(fd, times), "can't set time stamp of ", path);
        }
 
        if (preserve.mode) {
            timerInst(fchmod);
            throwcall::good0(fchmod(fd, readInitialStat.mode), "can't set mode of ", path);
        } else {
            auto oldmask = umask(0);
            timerInst(fchmod);
            throwcall::good0(fchmod(fd, modeBits & ~oldmask), "can't set mode of ", path);
            umask(oldmask);
        }
 
        if (gid != -1 || uid != -1) {
            timerInst(fchown);
            throwcall::good0(fchown(fd, uid, gid), "can't set owner/group (", uid, ",", gid, ") of ", path);
        } else if (preserve.ownership) {
            timerInst(fchown);
            throwcall::good0(fchown(fd, readInitialStat.ownerUid, readInitialStat.ownerGid),
                             "can't set owner/group (", readInitialStat.ownerUid, ",", readInitialStat.ownerGid, ") of ",
                             path);
        }
    }

References genericStat::getAtime(), genericStat::getMtime(), gid, throwcall::good0(), genericStat::mode, modeBits, genericStat::ownerGid, genericStat::ownerUid, preserve, timerInst, and uid.

Here is the call graph for this function:

getSize()

size_t outputHandler::daosFs::writerDaosFs::getSize ( ) const

override

Definition at line 339 of file outputHandlerDaosFs.cpp.

                                             {
        return writeInitialStat.st_size;
    }

parallelizable()

bool outputHandler::daosFs::writerDaosFs::parallelizable ( ) const

overridevirtual

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

Reimplemented from ioHandle.

Definition at line 336 of file outputHandlerDaosFs.cpp.

                                                  {
        return writeInitialStat.st_size == 0;
    }

seek()

void outputHandler::daosFs::writerDaosFs::seek ( size_t  position )

override

Definition at line 331 of file outputHandlerDaosFs.cpp.

                                                 {
        timerInst(lseek);
        throwcall::badval(lseek(fd, position, SEEK_SET),
                          -1, "can't seek ", path, " to ", position);
    }

References throwcall::badval(), and timerInst.

Here is the call graph for this function:

sync()

void outputHandler::daosFs::writerDaosFs::sync ( )

override

Definition at line 462 of file outputHandlerDaosFs.cpp.

                                  {
        timerInst(fsync);
        throwcall::good0(fsync(fd), "can't sync ", path);
    }

References throwcall::good0(), and timerInst.

Here is the call graph for this function:

writeBlock()

void outputHandler::daosFs::writerDaosFs::writeBlock ( const block &  b )

override

Definition at line 343 of file outputHandlerDaosFs.cpp.

                                                      {
        if (b.isHole()) { // just write a hole...
            static timer::anchor a("lseek");
            timer::instanceUnscoped i(a);
            auto currentPosition = throwcall::badval(lseek(fd, 0, SEEK_CUR), -1, "lseek to determine position on", path);
            i.stop();
            auto holeEnd  = currentPosition + b.size();
            {
                timerInst(ftruncate);
                throwcall::good0(ftruncate(fd, holeEnd),
                                 "fruncate ", path, " to ", holeEnd);
            }
            timerInst(lseek);
            throwcall::badval(lseek(fd, holeEnd, SEEK_SET), -1,
                              "can't seek to hole end (", holeEnd, ") in ", path);
            return;
        }
 
        size_t bytes_writen_so_far = 0;
 
        while (bytes_writen_so_far < b.size()) {
            auto count = b.size() - bytes_writen_so_far;
 
            if (count > blockSize) {
                count = blockSize;
            }
            writeRateLimit.wait();
            timerInst(write);
            auto bytes_writen = throwcall::badval(write(fd, b.bufferAt(bytes_writen_so_far), count),
                                                  -1, "write failed on ", path);
            writeRateLimit.update(bytes_writen);
            bytes_writen_so_far += bytes_writen;
        }
    }

References throwcall::badval(), block::bufferAt(), throwcall::good0(), block::isHole(), block::size(), timer::instanceUnscoped::stop(), timerInst, throttle::watch::update(), throttle::watch::wait(), and writeRateLimit.

Here is the call graph for this function:

writeBlockP()

void outputHandler::daosFs::writerDaosFs::writeBlockP ( const block &  b )

override

Definition at line 379 of file outputHandlerDaosFs.cpp.

                                                       {
        size_t bytes_writen_so_far = 0;
 
        while (bytes_writen_so_far < b.size()) {
            auto count = b.size() - bytes_writen_so_far;
 
            if (count > blockSize) {
                count = blockSize;
            }
            timerInst(pwrite);
            auto bytes_writen = throwcall::badval(pwrite(fd, b.bufferAt(bytes_writen_so_far), count, b.offset() + bytes_writen_so_far),
                                                  -1, "write failed on ", path);
            bytes_writen_so_far += bytes_writen;
        }
    }

References throwcall::badval(), block::bufferAt(), block::offset(), block::size(), and timerInst.

Here is the call graph for this function:

Member Data Documentation

aclData

std::unique_ptr<acl::list> outputHandler::daosFs::writerDaosFs::aclData

protected

Definition at line 17 of file outputHandlerDaosFs.h.

attrData

std::unique_ptr<ioHandle::attrDataType> outputHandler::daosFs::writerDaosFs::attrData

protected

Definition at line 16 of file outputHandlerDaosFs.h.

writeInitialStat

struct stat outputHandler::daosFs::writerDaosFs::writeInitialStat

protected

Definition at line 15 of file outputHandlerDaosFs.h.

Referenced by writerDaosFs().

---

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

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