outputHandler::posixFile::writerPosixFile Class Reference

#include <outputHandlerPosixFile.h>

Inheritance diagram for outputHandler::posixFile::writerPosixFile:

Collaboration diagram for outputHandler::posixFile::writerPosixFile:

Public Member Functions
	writerPosixFile (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)
	writerPosixFile (std::string &aPath, bool noWrite, std::unique_ptr< ioHandle::attrDataType > aAttrData, std::unique_ptr< acl::list > aAclData, base &handler)
void	closeAndRemoveBadCopy () override
	~writerPosixFile () 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 outputHandler::base::writer
	writer ()=default
virtual	~writer ()=default
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...
Public Member Functions inherited from posixFileIoCommon
	posixFileIoCommon (const std::string &aPath)
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...

Protected Attributes
struct stat	writeInitialStat
std::unique_ptr< ioHandle::attrDataType >	attrData
std::unique_ptr< acl::list >	aclData
Protected Attributes inherited from ioHandle
size_t	blockSize
	in bytes, block size to be used when reading or writing More...
Protected Attributes inherited from posixFileIoCommon
const std::string &	path
int	fd = -1

Additional Inherited Members
Protected Member Functions inherited from unwindCheck
	unwindCheck ()=default
	~unwindCheck ()=default
bool	isUnwinding () const
Protected 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...

Detailed Description

Definition at line 13 of file outputHandlerPosixFile.h.

Constructor & Destructor Documentation

writerPosixFile() [1/2]

outputHandler::posixFile::writerPosixFile::writerPosixFile	(	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
	)

Definition at line 231 of file outputHandlerPosixFile.cpp.

                                            :
        posixFileIoCommon(aPath),
        attrData(std::move(aAttrData)),
        aclData(std::move(aAclData)) {
        bool haveWriteStat = false;
        if (noWrite) {
            fd = -1;
            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
            if (mightAppend) {
                auto retval = stat(path.c_str(), &writeInitialStat);
                if (retval) {
                    if (errno != ENOENT) {
                        throwcall::good0(retval, "can't stat destination file ", path);
                    }
                } else {
                    haveWriteStat = true;
                    if (static_cast<size_t>(writeInitialStat.st_size) < sourceSize &&
                            sourceSize > readBlockSize) {
                        state |= copyRequest::stateBitType::append;
                        openMode = O_WRONLY;
                    }
                }
            }
            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(), posixFileIoCommon::fd, throwcall::good0(), posixFileIoCommon::path, outputHandler::slownessThreshold, timerInstTO, and writeInitialStat.

Here is the call graph for this function:

writerPosixFile() [2/2]

outputHandler::posixFile::writerPosixFile::writerPosixFile	(	std::string &	aPath,
		bool	noWrite,
		std::unique_ptr< ioHandle::attrDataType >	aAttrData,
		std::unique_ptr< acl::list >	aAclData,
		base &	handler
	)

Definition at line 276 of file outputHandlerPosixFile.cpp.

                                                              :
        posixFileIoCommon(aPath),
        attrData(std::move(aAttrData)),
        aclData(std::move(aAclData)) {
        if (noWrite) {
            fd = -1;
            blockSize = 4096;
        } else {
            static const std::string pattern("XXXXXX.tmp");
            std::vector<char> tmpName;
            tmpName.reserve(path.size() + pattern.size() + 1);
            tmpName.insert(tmpName.end(), path.cbegin(), path.cend());
            handler.shortenNameToMax(path,tmpName,pattern);
            tmpName.insert(tmpName.end(), pattern.cbegin(), pattern.cend());
            tmpName.push_back('\0');
            timerInstTO(mkstemps,slownessThreshold,tmpName);
            fd = throwcall::badval(mkstemps(tmpName.data(), 4),
                                   -1, "can't open ", tmpName.data(), " for writing");
            aPath.replace(0, path.size(), tmpName.data(), tmpName.size());
            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 throwcall::badval(), ioHandle::blockSize, posixFileIoCommon::fd, throwcall::good0(), posixFileIoCommon::path, outputHandler::base::shortenNameToMax(), outputHandler::slownessThreshold, timerInstTO, and writeInitialStat.

Here is the call graph for this function:

~writerPosixFile()

outputHandler::posixFile::writerPosixFile::~writerPosixFile ( )

overridenoexcept

Definition at line 323 of file outputHandlerPosixFile.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::posixFile::writerPosixFile::closeAndRemoveBadCopy ( )

overridevirtual

Implements outputHandler::base::writer.

Definition at line 307 of file outputHandlerPosixFile.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::posixFile::writerPosixFile::doAttributePreservations ( const genericStat &  readInitialStat )

overridevirtual

Implements outputHandler::base::writer.

Definition at line 410 of file outputHandlerPosixFile.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::posixFile::writerPosixFile::getSize ( ) const

overridevirtual

Reimplemented from outputHandler::base::writer.

Definition at line 354 of file outputHandlerPosixFile.cpp.

                                                   {
        return writeInitialStat.st_size;
    }

parallelizable()

bool outputHandler::posixFile::writerPosixFile::parallelizable ( ) const

overridevirtual

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

Reimplemented from ioHandle.

Definition at line 351 of file outputHandlerPosixFile.cpp.

                                                        {
        return writeInitialStat.st_size == 0;
    }

seek()

void outputHandler::posixFile::writerPosixFile::seek ( size_t  position )

overridevirtual

Reimplemented from outputHandler::base::writer.

Definition at line 346 of file outputHandlerPosixFile.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::posixFile::writerPosixFile::sync ( )

overridevirtual

Implements outputHandler::base::writer.

Definition at line 477 of file outputHandlerPosixFile.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::posixFile::writerPosixFile::writeBlock ( const block &  b )

overridevirtual

Implements outputHandler::base::writer.

Definition at line 358 of file outputHandlerPosixFile.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.

Referenced by outputHandler::Gpfs::writerGpfs::writeBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBlockP()

void outputHandler::posixFile::writerPosixFile::writeBlockP ( const block &  b )

overridevirtual

Reimplemented from outputHandler::base::writer.

Definition at line 394 of file outputHandlerPosixFile.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.

Referenced by outputHandler::Gpfs::writerGpfs::writeBlockP().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

aclData

std::unique_ptr<acl::list> outputHandler::posixFile::writerPosixFile::aclData

protected

Definition at line 17 of file outputHandlerPosixFile.h.

attrData

std::unique_ptr<ioHandle::attrDataType> outputHandler::posixFile::writerPosixFile::attrData

protected

Definition at line 16 of file outputHandlerPosixFile.h.

writeInitialStat

struct stat outputHandler::posixFile::writerPosixFile::writeInitialStat

protected

Definition at line 15 of file outputHandlerPosixFile.h.

Referenced by writerPosixFile().

---

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

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