outputHandler::libssh::writerLibssh Class Reference

#include <outputHandlerLibssh.h>

Inheritance diagram for outputHandler::libssh::writerLibssh:

Collaboration diagram for outputHandler::libssh::writerLibssh:

Public Member Functions
	writerLibssh (const std::string &aPath, libsshCommon &aHandler, bool mightAppend, size_t sourceSize, size_t readBlockSize, copyRequest::stateType &state, bool noWrite, std::unique_ptr< ioHandle::attrDataType > attrData, std::unique_ptr< acl::list > aclData)
	~writerLibssh () noexcept(false) override
void	closeAndRemoveBadCopy () override
void	seek (size_t position) override
size_t	getSize () const override
void	writeBlock (const block &b) override
void	doAttributePreservations (const genericStat &readInitialStat) override
void	sync () override
Public Member Functions inherited from libsshIoCommon
	libsshIoCommon (const std::string &aPath, libsshCommon &aHandler)
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...

Protected Attributes
sftp_attributes	writeInitialStat
std::unique_ptr< ioHandle::attrDataType >	attrData
Protected Attributes inherited from libsshIoCommon
libsshCommon &	handler
const std::string	path
sftp_file	file
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 outputHandlerLibssh.h.

Constructor & Destructor Documentation

writerLibssh()

outputHandler::libssh::writerLibssh::writerLibssh	(	const std::string &	aPath,
		libsshCommon &	aHandler,
		bool	mightAppend,
		size_t	sourceSize,
		size_t	readBlockSize,
		copyRequest::stateType &	state,
		bool	noWrite,
		std::unique_ptr< ioHandle::attrDataType >	attrData,
		std::unique_ptr< acl::list >	aclData
	)

Definition at line 220 of file outputHandlerLibssh.cpp.

                                                                :
        libsshIoCommon(aPath, aHandler),
        writeInitialStat(nullptr),
        attrData(std::move(aAttrData)) {
        if (noWrite) {
            file = nullptr;
            blockSize = 1024 * 1024;
        } 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) {
                writeInitialStat = sftp_stat(handler.sftp, path.c_str());
                if (writeInitialStat == nullptr) {
                    if (sftp_get_error(handler.sftp) != SSH_FX_NO_SUCH_FILE) {
                        throwcall::sftp::good0(1, handler, "can't stat destination file ", path);
                    }
                } else {
                    if (static_cast<size_t>(writeInitialStat->size) < sourceSize &&
                            sourceSize > readBlockSize) {
                        state |= copyRequest::stateBitType::append;
                        openMode = O_WRONLY;
                    }
                }
            }
            static timer::anchor a("sftp_open");
            timer::instanceUnscoped i(a);
            file = throwcall::sftp::badval(sftp_open(handler.sftp, path.c_str(), openMode, S_IWUSR),
                                           nullptr, handler,
                                           "can't open ", path, " for writing");
            i.stop();
            if (writeInitialStat == nullptr) {
                timerInst(sftp_fstat);
                writeInitialStat = throwcall::sftp::badval(sftp_fstat(file), nullptr,
                                   handler,
                                   "can't stat destination file ", path);
            }
            blockSize = 16 * 1024;
        }
    };

References copyRequest::append, throwcall::sftp::badval(), ioHandle::blockSize, enumAsBitmask< T >::clear(), libsshIoCommon::file, throwcall::sftp::good0(), libsshIoCommon::handler, libsshIoCommon::path, libsshCommon::sftp, timer::instanceUnscoped::stop(), timerInst, and writeInitialStat.

Here is the call graph for this function:

~writerLibssh()

outputHandler::libssh::writerLibssh::~writerLibssh ( )

overridenoexcept

Definition at line 290 of file outputHandlerLibssh.cpp.

                                                      {
        if (writeInitialStat != nullptr) {
            sftp_attributes_free(writeInitialStat);
        }
        if (file != nullptr) {
            if (isUnwinding()) {
                closeAndRemoveBadCopy();
                return;
            }
            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;
                }
            }
            timerInst(sftp_close);
            throwcall::badval(sftp_close(file), SSH_ERROR, "can't close ", path);
        }
    };

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

Here is the call graph for this function:

Member Function Documentation

closeAndRemoveBadCopy()

void outputHandler::libssh::writerLibssh::closeAndRemoveBadCopy ( )

override

Definition at line 268 of file outputHandlerLibssh.cpp.

                                                   {
        static timer::anchor a("sftp_close");
        timer::instanceUnscoped i(a);
        if (sftp_close(file) == SSH_ERROR) {
            errMsg::emit(errMsg::level::debug, errMsg::location(),
                         path, "close during unwind ",
                         "sftp error ", sftp_get_error(handler.sftp),
                         ", ssh error ", ssh_get_error(handler.session));
        }
        i.stop();
        errMsg::emit(errMsg::level::debug, errMsg::location(),
                     path, "unlink failed copy", "due to exception");
        timerInst(sftp_unlink);
        auto retval = sftp_unlink(handler.sftp, path.c_str());
        if (retval && sftp_get_error(handler.sftp) != SSH_FX_NO_SUCH_FILE) {
            errMsg::emit(errMsg::level::err, errMsg::location(),
                         path, "can't remove bad copy ",
                         "sftp error ", sftp_get_error(handler.sftp),
                         ", ssh error ", ssh_get_error(handler.session));
        }
    };

References errMsg::debug, errMsg::emit(), errMsg::err, timer::instanceUnscoped::stop(), and timerInst.

Here is the call graph for this function:

doAttributePreservations()

void outputHandler::libssh::writerLibssh::doAttributePreservations ( const genericStat &  readInitialStat )

override

Definition at line 353 of file outputHandlerLibssh.cpp.

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

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

Here is the call graph for this function:

getSize()

size_t outputHandler::libssh::writerLibssh::getSize ( ) const

override

Definition at line 320 of file outputHandlerLibssh.cpp.

                                             {
        return writeInitialStat->size;
    }

seek()

void outputHandler::libssh::writerLibssh::seek ( size_t  position )

override

Definition at line 316 of file outputHandlerLibssh.cpp.

                                                 {
        throwcall::sftp::good0(sftp_seek64(file, position), handler,
                               "can't seek ", path, " to ", position);
    }

References throwcall::sftp::good0().

Here is the call graph for this function:

sync()

void outputHandler::libssh::writerLibssh::sync ( )

override

Definition at line 390 of file outputHandlerLibssh.cpp.

                                  {
        // old versions of libssh do not have fsync...
        #if LIBSFTP_VERSION > 3
        throwcall::sftp::good0(sftp_fsync(file), handler.sftp,
                               "can't sync ", path);
        #endif
    }

References throwcall::sftp::good0().

Here is the call graph for this function:

writeBlock()

void outputHandler::libssh::writerLibssh::writeBlock ( const block &  b )

override

Definition at line 324 of file outputHandlerLibssh.cpp.

                                                      {
        if (b.isHole()) { // just write a hole...
            auto currentPosition = sftp_tell64(file); // cannot fail, in constrast to docs
            auto holeEnd  = currentPosition + b.size();
            throwcall::sftp::good0(sftp_seek64(file, holeEnd), handler,
                                   "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(sftp_write);
            auto bytes_writen = sftp_write(file, b.bufferAt(bytes_writen_so_far), count);
            if (bytes_writen < 0) {
                throwcall::sftp::good0(-1, handler,  "write failed on ", path);
            }
            writeRateLimit.update(bytes_writen);
            bytes_writen_so_far += bytes_writen;
        }
    }

References block::bufferAt(), throwcall::sftp::good0(), block::isHole(), block::size(), timerInst, throttle::watch::update(), throttle::watch::wait(), and writeRateLimit.

Here is the call graph for this function:

Member Data Documentation

attrData

std::unique_ptr<ioHandle::attrDataType> outputHandler::libssh::writerLibssh::attrData

protected

Definition at line 16 of file outputHandlerLibssh.h.

writeInitialStat

sftp_attributes outputHandler::libssh::writerLibssh::writeInitialStat

protected

Definition at line 15 of file outputHandlerLibssh.h.

Referenced by writerLibssh().

---

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

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