outputHandler::dcap::writerDcap Class Reference

#include <outputHandlerDcap.h>

Inheritance diagram for outputHandler::dcap::writerDcap:

Collaboration diagram for outputHandler::dcap::writerDcap:

Public Member Functions
	writerDcap (const std::string &aPath, bool mightAppend, size_t sourceSize, size_t readBlockSize, copyRequest::stateType &state, bool noWrite, std::unique_ptr< acl::list > aAclData)
	~writerDcap () noexcept(false) override
void	closeAndRemoveBadCopy () override
void	writeBlock (const block &b) override
void	doAttributePreservations (const genericStat &readInitialStat) override
void	sync () 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...

Static Protected Attributes
static options::single< bool >	unsafeWrite
static options::single< bool >	noChecksum

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 12 of file outputHandlerDcap.h.

Constructor & Destructor Documentation

writerDcap()

outputHandler::dcap::writerDcap::writerDcap	(	const std::string &	aPath,
		bool	mightAppend,
		size_t	sourceSize,
		size_t	readBlockSize,
		copyRequest::stateType &	state,
		bool	noWrite,
		std::unique_ptr< acl::list >	aAclData
	)

Definition at line 246 of file outputHandlerDcap.cpp.

                                                                :
        dcapIoCommon(aPath) {
        blockSize = 16 * 1024 * 1024;
        if (noWrite) {
            fd = -1;
        } else {
            dCapLock extraOptionLock;
            std::string options("-alloc-size=");
            options += std::to_string(sourceSize);
            dc_setExtraOption(const_cast<char*>(options.c_str())); // const cast to work around broken interface
            if (aclData) {
                setAclData(*aclData);
            }
            auto openMode = O_CREAT | O_TRUNC | O_WRONLY;
            state.clear(copyRequest::stateBitType::append); // clear any old append sets, may be left over from former attempts
            // No appends on dcache, it's a WORM system
            fd = throwcall::dcap::badval(dc_open(path.c_str(), openMode, S_IWUSR | S_IRUSR),
                                         -1, "can't open ", path, " for writing");
            if (unsafeWrite) {
                dc_unsafeWrite(fd);
            }
            if (noChecksum) {
                dc_noCheckSum(fd);
            }
        }
    };

References copyRequest::append, throwcall::dcap::badval(), ioHandle::blockSize, enumAsBitmask< T >::clear(), dcapIoCommon::fd, noChecksum, dcapIoCommon::path, outputHandler::dcap::setAclData(), and unsafeWrite.

Here is the call graph for this function:

~writerDcap()

outputHandler::dcap::writerDcap::~writerDcap ( )

overridenoexcept

Definition at line 293 of file outputHandlerDcap.cpp.

                                                {
        if (fd != -1) {
            dCapLock extraOptionLock;
            if (isUnwinding()) {
                closeAndRemoveBadCopy();
                return;
            }
            throwcall::dcap::good0(dc_close(fd), "can't close ", path);
        }
    };

References throwcall::dcap::good0().

Here is the call graph for this function:

Member Function Documentation

closeAndRemoveBadCopy()

void outputHandler::dcap::writerDcap::closeAndRemoveBadCopy ( )

override

Definition at line 278 of file outputHandlerDcap.cpp.

                                               {
        if (dc_close(fd) != 0) {
            errMsg::emit(errMsg::level::debug, errMsg::location(),
                         path, "close during unwind ",
                         dc_strerror(dc_errno));
        }
        errMsg::emit(errMsg::level::debug, errMsg::location(),
                     path, "unlink failed copy", "due to exception");
        if (dc_unlink(path.c_str()) != 0) {
            errMsg::emit(errMsg::level::err, errMsg::location(),
                         path, "can't remove bad copy ",
                         dc_strerror(dc_errno));
        }
    };

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

Here is the call graph for this function:

doAttributePreservations()

void outputHandler::dcap::writerDcap::doAttributePreservations ( const genericStat &  readInitialStat )

override

Definition at line 327 of file outputHandlerDcap.cpp.

                                                                      {
        throw unimplementedActionError("for dCap doAttributePreservations must be used with setAttributesAfterClose");
    }

sync()

void outputHandler::dcap::writerDcap::sync ( )

override

Definition at line 373 of file outputHandlerDcap.cpp.

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

References throwcall::dcap::good0().

Here is the call graph for this function:

writeBlock()

void outputHandler::dcap::writerDcap::writeBlock ( const block &  b )

override

Definition at line 305 of file outputHandlerDcap.cpp.

                                                  {
        size_t bytes_writen_so_far = 0;
 
        while (bytes_writen_so_far < b.size()) {
            writeRateLimit.wait();
            auto count = b.size() - bytes_writen_so_far;
 
            if (b.isHole()) { // just write zeroes
                count = std::min({count, blockSize, block::nullBufferSize()});
            } else {
                count = std::min(count, blockSize);
            }
            auto bytes_writen = throwcall::dcap::badval(dc_write(fd, b.bufferAt(bytes_writen_so_far), count),
                                -1, "write failed on ", path);
            if (bytes_writen == 0) {
                throw std::runtime_error("wrote 0 bytes for " + path);
            }
            writeRateLimit.update(bytes_writen);
            bytes_writen_so_far += bytes_writen;
        }
    }

References throwcall::dcap::badval(), block::bufferAt(), block::isHole(), block::nullBufferSize(), block::size(), throttle::watch::update(), throttle::watch::wait(), and writeRateLimit.

Here is the call graph for this function:

Member Data Documentation

noChecksum

options::single<bool> outputHandler::dcap::writerDcap::noChecksum

staticprotected

Definition at line 15 of file outputHandlerDcap.h.

Referenced by writerDcap().

unsafeWrite

options::single<bool> outputHandler::dcap::writerDcap::unsafeWrite

staticprotected

Definition at line 14 of file outputHandlerDcap.h.

Referenced by writerDcap().

---

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

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