outputHandler::dcap Class Reference

#include <outputHandlerDcap.h>

Inheritance diagram for outputHandler::dcap:

Collaboration diagram for outputHandler::dcap:

Classes
class	writerDcap

Public Member Functions
	dcap ()
	~dcap () override=default
std::unique_ptr< writer >	newWriter (const std::string &path, bool mightAppend, size_t sourceSize, size_t readBlockSize, copyRequest::stateType &state, bool noWrite, std::unique_ptr< ioHandle::attrDataType >, std::unique_ptr< acl::list > aclData) override
void	ensureParentDirs (const std::string &path, const std::string &srcPath, inputHandler::base *InputHandler) override
void	remove (const std::string &path, copyRequest::stateType &state) override
bool	renameSimple (const std::string &fromPath, const std::string &toPath) override
base::renameRetvalType	rename (const std::string &fromPath, const std::unique_ptr< const genericStat > &readInitialStat, const std::string &toPath, copyRequest::stateType &state) override
void	doAttributePreservations (const std::string &path, const genericStat &stat) override
Public Member Functions inherited from outputHandler::base
	~base () override=default
virtual std::unique_ptr< writer >	newTmpWriter (std::string &path, size_t sourceSize, bool noWrite, std::unique_ptr< ioHandle::attrDataType > attrData, std::unique_ptr< acl::list > aclData)
virtual void	createSymlink (const std::vector< char > &, const std::string &, uid_t, gid_t)
virtual size_t	getMaxNameLength (const std::string &dirPath)
template<class C >
void	shortenNameToMax (const std::string &path, C &pathBuf, const std::string &suffix)
Public Member Functions inherited from pathHandler
virtual	~pathHandler ()=default
virtual std::string	getXattr (const std::string &, const std::string &)
Public Member Functions inherited from dcapCommon
	dcapCommon ()
bool	pathExists (const std::string &path) override
std::unique_ptr< const genericStat >	getStat (const std::string &path, bool followLink) override

Static Public Attributes
static const std::string	parPrefix

Static Protected Member Functions
static void	setAclData (const acl::list &aclData, bool isDir=false)
Static Protected Member Functions inherited from outputHandler::base
static std::map< std::string, factoryClass * > &	getFactoryMap ()

Static Private Attributes
static factoryTemplate< dcap >	factory

Additional Inherited Members
Public Types inherited from outputHandler::base
enum	renameRetvalType { renameRetvalType::ok, renameRetvalType::fileChanged, renameRetvalType::fileVanished, renameRetvalType::cantHappen }
Static Public Member Functions inherited from outputHandler::base
static base *	newHandler (const std::string &name)
template<class T >
static void	addAllowedNamesToOption (T &option)
Static Public Member Functions inherited from dcapCommon
static std::string	fixPathUrl (const std::string &path)
Protected Member Functions inherited from outputHandler::base
	base ()=default

Detailed Description

Definition at line 8 of file outputHandlerDcap.h.

Constructor & Destructor Documentation

dcap()

outputHandler::dcap::dcap

(

)

Definition at line 27 of file outputHandlerDcap.cpp.

               {
        if (copyRequest::base::setAttributesAfterClose == false) {
            errMsg::emit(errMsg::level::info, errMsg::location(),
                         "--", "dcap output handler",
                         "setting setAttributesAfterClose automatically");
            copyRequest::base::setAttributesAfterClose = true;
        }
    }

References errMsg::emit(), errMsg::info, and copyRequest::base::setAttributesAfterClose.

Here is the call graph for this function:

~dcap()

outputHandler::dcap::~dcap ( )

overridedefault

Member Function Documentation

doAttributePreservations()

void outputHandler::dcap::doAttributePreservations ( const std::string &  path, const genericStat &  stat  )

overridevirtual

Reimplemented from outputHandler::base.

Definition at line 331 of file outputHandlerDcap.cpp.

                                                                 {
        if (preserve.timestamps) { // for mtime we must use a parallel nfs mount, there is no function in the dcap lib.
            struct timespec times[2];
            times[0].tv_nsec = UTIME_OMIT; // leave atime unchanged
            stat.getMtime(times[1]);
            auto serverStart = path.find("://");
            if (serverStart == std::string::npos) {
                throw std::runtime_error(path + " contains no \"://\"");
            }
            auto realPathStart = path.find("/", serverStart + 3);
            if (realPathStart == std::string::npos) {
                throw std::runtime_error(path + " contains no path after server part");
            }
            throwcall::good0(utimensat(0, path.c_str() + realPathStart,
                                       times, 0),
                             "can't set mtime on ", path.c_str() + realPathStart);
        }
        dCapLock extraOptionLock;
        if (preserve.mode) {
            throwcall::dcap::good0(dc_chmod(path.c_str(), stat.mode), "can't set mode of ", path);
        } else {
            auto oldmask = umask(0);
            auto retval = dc_chmod(path.c_str(), modeBits & ~oldmask);
            if (retval != 0) {
                errMsg::emit(errMsg::level::notice, errMsg::location(),
                             path, "chmod", "can't set mode ", dc_errno, " (", dc_strerror(dc_errno), ") ");
            }
            //throwcall::dcap::good0(dc_chmod(path.c_str(), modeBits & ~oldmask), "can't set mode of ", path);
            umask(oldmask);
        }
 
        if (gid != -1 || uid != -1) {
            throwcall::dcap::good0(dc_chown(path.c_str(), uid, gid), "can't set owner/group (", uid, ",", gid, ") of ", path);
        } else if (preserve.ownership) {
            throwcall::dcap::good0(dc_chown(path.c_str(), stat.ownerUid, stat.ownerGid),
                                   "can't set owner/group (", stat.ownerUid, ",", stat.ownerGid, ") of ",
                                   path);
        }
    }

References errMsg::emit(), genericStat::getMtime(), gid, throwcall::dcap::good0(), throwcall::good0(), genericStat::mode, modeBits, errMsg::notice, genericStat::ownerGid, genericStat::ownerUid, preserve, and uid.

Here is the call graph for this function:

ensureParentDirs()

void outputHandler::dcap::ensureParentDirs ( const std::string &  path, const std::string &  srcPath, inputHandler::base *  InputHandler  )

overridevirtual

Implements outputHandler::base.

Definition at line 36 of file outputHandlerDcap.cpp.

                                                                {
        std::vector<std::remove_reference<decltype(path)>::type::value_type> disposable_buffer(path.c_str(), path.c_str() + path.size() + 1);
        std::string dir(dirname(disposable_buffer.data()));
        struct dcapStat statbuf;
        int statResult;
        {
            dCapLock extraOptionLock;
            statResult = dc_stat(fixPathUrl(dir).c_str(), &statbuf);
        }
        if (statResult) {
            if (errno == ENOENT) {
                auto srcDir = srcPath.substr(0, srcPath.find_last_of('/'));
                while (srcDir.back() == '/') {
                    srcDir.pop_back();
                }
                ensureParentDirs(dir, srcDir, InputHandler);
                dCapLock extraOptionLock;
                if (preserve.acls) {
                    auto aclData = InputHandler->getAclData(srcDir);
                    if (aclData) {
                        setAclData(*aclData, true);
                    }
                }
                auto result = dc_mkdir(fixPathUrl(dir).c_str(), 0777u);
 
                if (result != 0 && errno == EEXIST) {
                    return; // we lost a race with another copy process...
                }
 
                throwcall::dcap::good0(result, "can't create directory ", dir);
 
                if (gid != -1 || uid != -1) {
                    throwcall::dcap::good0(dc_chown(fixPathUrl(dir).c_str(), uid, gid), "can't set owner/group (", uid, ",", gid, ") on ", dir);
                }
            }
        } else if (! S_ISDIR(statbuf.st_mode)) {
            errMsg::emit(errMsg::level::info, errMsg::location(),
                         dir, "ensure parents",
                         "is not a directory (st_mode is ", statbuf.st_mode, ") but should be");
        }
    }

References dcapStat, errMsg::emit(), dcapCommon::fixPathUrl(), inputHandler::base::getAclData(), gid, throwcall::dcap::good0(), errMsg::info, preserve, setAclData(), and uid.

Here is the call graph for this function:

newWriter()

std::unique_ptr< base::writer > outputHandler::dcap::newWriter ( const std::string &  path, bool  mightAppend, size_t  sourceSize, size_t  readBlockSize, copyRequest::stateType &  state, bool  noWrite, std::unique_ptr< ioHandle::attrDataType >  , std::unique_ptr< acl::list >  aclData  )

overridevirtual

Implements outputHandler::base.

Definition at line 13 of file outputHandlerDcap.cpp.

                                            {
        return std::unique_ptr<base::writer>(new writerDcap(path, mightAppend,
                                             sourceSize, readBlockSize,
                                             state, noWrite,
                                             std::move(aclData)));
    }

remove()

void outputHandler::dcap::remove ( const std::string &  path, copyRequest::stateType &  state  )

overridevirtual

Implements outputHandler::base.

Definition at line 81 of file outputHandlerDcap.cpp.

                                                                        {
        dCapLock extraOptionLock;
        struct dcapStat dsttat;
        {
            auto retval = dc_lstat(fixPathUrl(path).c_str(), &dsttat);
 
            if (retval && errno == ENOENT) {
                state |= copyRequest::stateBitType::vanished;
                return;
            }
        }
        if (S_ISDIR(dsttat.st_mode)) {
            auto retval = dc_rmdir(fixPathUrl(path).c_str());
            if (retval) {
                switch (errno) {
                    case ENOENT:
                        state |= copyRequest::stateBitType::vanished;
                        return;
                    case ENOTEMPTY:
                    case EEXIST: // POSIX.1 allows this also
                        errMsg::emit(errMsg::level::info, errMsg::location(),
                                     path, "remove", "directory not empty but should be removed");
                        state |= copyRequest::stateBitType::failed;
                        return;
                }
                throwcall::dcap::good0(retval, "can't reemove directory ", path);
            } else {
                state |= copyRequest::stateBitType::done;
                return;
            }
        } else {
            auto retval = dc_unlink(fixPathUrl(path).c_str());
 
            if (retval && errno == ENOENT) {
                state |= copyRequest::stateBitType::vanished;
            } else {
                throwcall::dcap::good0(retval, "can't unlink ", path);
            }
            state |= copyRequest::stateBitType::done;
        }
    }

References dcapStat, copyRequest::done, errMsg::emit(), copyRequest::failed, dcapCommon::fixPathUrl(), throwcall::dcap::good0(), errMsg::info, and copyRequest::vanished.

Here is the call graph for this function:

rename()

base::renameRetvalType outputHandler::dcap::rename ( const std::string &  fromPath, const std::unique_ptr< const genericStat > &  readInitialStat, const std::string &  toPath, copyRequest::stateType &  state  )

overridevirtual

Bug:

what if at the end a directory is renamed?

Implements outputHandler::base.

Definition at line 136 of file outputHandlerDcap.cpp.

                                                                     {
        dCapLock extraOptionLock;
        struct dcapStat fromPathStatBuf;
        auto statRetVal = dc_stat(fixPathUrl(fromPath).c_str(), &fromPathStatBuf);
        if (statRetVal && (errno == ENOENT || errno == ENOTDIR)) {
            if (readInitialStat && readInitialStat->isDir()) { // no need to act, dirs are created on the fly
                state |= copyRequest::stateBitType::ignore;
                return base::renameRetvalType::ok;
            }
            return base::renameRetvalType::fileVanished;
        } else if (statRetVal) { // curious error
            throwcall::dcap::good0(statRetVal, "can't stat '", fromPath, "'");
            return base::renameRetvalType::cantHappen; // never reached
        }
        genericStat fromPathStat(fromPathStatBuf, std::chrono::seconds(1));
        if (! readInitialStat || (
                    ! readInitialStat->isDir() &&
                    (fromPathStat.size != readInitialStat->size
                     || !fromPathStat.isSameMtimeAs(*readInitialStat)))) {
            // the copy on fromPath is not up to date, create a new copy
            errMsg::emit(errMsg::level::info, errMsg::location(),
                         fromPath, "move",
                         "file (", toPath, ") changed unexpectedly, doing fresh copy");
            return base::renameRetvalType::fileChanged;
        } else { // try to move the existing copy
            auto retval = dc_rename(fixPathUrl(fromPath).c_str(), fixPathUrl(toPath).c_str());
 
            if (retval && (errno == ENOENT || errno == ENOTDIR)) {
                if (readInitialStat->isDir()) { // no need to act, dirs are created on the fly
                    state |= copyRequest::stateBitType::ignore;
                    return base::renameRetvalType::ok;
                }
                errMsg::emit(errMsg::level::info, errMsg::location(),
                             fromPath, "move",
                             "vanished unexpectedly, doing fresh copy");
                // file was probably not copied yet, try to copy it from the move target
                return base::renameRetvalType::fileVanished;
            } else {
                throwcall::dcap::good0(retval, "can't rename '", fromPath, "' to '", toPath, "'");
                state |= copyRequest::stateBitType::done;
                return base::renameRetvalType::ok;
            }
        }
        return base::renameRetvalType::cantHappen;
    }

References outputHandler::base::cantHappen, dcapStat, copyRequest::done, errMsg::emit(), outputHandler::base::fileChanged, outputHandler::base::fileVanished, dcapCommon::fixPathUrl(), throwcall::dcap::good0(), copyRequest::ignore, errMsg::info, genericStat::isDir(), genericStat::isSameMtimeAs(), outputHandler::base::ok, and genericStat::size.

Here is the call graph for this function:

renameSimple()

bool outputHandler::dcap::renameSimple ( const std::string &  fromPath, const std::string &  toPath  )

overridevirtual

Implements outputHandler::base.

Definition at line 124 of file outputHandlerDcap.cpp.

                                                     {
        dCapLock extraOptionLock;
        auto retval = dc_rename(fromPath.c_str(), toPath.c_str());
        //find out proper errno
        //      if (retval && (errno == ENOENT || errno == ENOTDIR)) {
        //      return false;
        //}
        throwcall::dcap::good0(retval, "can't rename '", fromPath, "' to '", toPath, "'");
        return true;
    }

References throwcall::dcap::good0().

Here is the call graph for this function:

setAclData()

void outputHandler::dcap::setAclData ( const acl::list &  aclData, bool  isDir = false  )

staticprotected

Definition at line 188 of file outputHandlerDcap.cpp.

                                                            {
        if (aclData.entries.empty()) {
            return;
        }
        bool needSpace = false;
        std::string result(" -acl=\"");
        for (const auto& entry : aclData.entries) {
            if (needSpace) {
                result += " ";
            }
            needSpace = true;
            result += entry.isAllowedType() ? "A:" : "D:";
            result += entry.isFlagSet(acl::list::entryType::flagsType::identifier_group) &&
                      ! entry.isFlagSet(acl::list::entryType::flagsType::special_who)
                      ? "g:" : ":";
            if (entry.isFlagSet(acl::list::entryType::flagsType::special_who)) {
                switch (entry.e_id) {
                    case acl::list::entryType::specialIdType::owner_special_id:
                        result += "OWNER@:";
                        break;
                    case acl::list::entryType::specialIdType::group_special_id:
                        result += "GROUP@:";
                        break;
                    case acl::list::entryType::specialIdType::everyone_special_id:
                        result += "EVERYONE@:";
                        break;
                    default:
                        throw std::runtime_error("illegal special id");
                }
            } else {
                result += std::to_string(entry.e_id);
                result += ":";
            }
            for (const auto& item : acl::list::entryType::aclMaskBits) {
                auto mask = entry._mask;
                if (isDir) {
                    mask.clear(acl::list::entryType::maskType::delete_child);
                }
                if (mask & item.first) {
                    result += item.second;
                }
            }
        }
        result += "\"";
        dc_setExtraOption(const_cast<char*>(result.c_str())); // ugly const cast due to bad dCap interface
 
    };

References acl::list::entryType::aclMaskBits, acl::list::entryType::delete_child, acl::list::entries, acl::list::entryType::identifier_group, and acl::list::entryType::special_who.

Referenced by ensureParentDirs(), and outputHandler::dcap::writerDcap::writerDcap().

Here is the caller graph for this function:

Member Data Documentation

factory

factoryTemplate<dcap> outputHandler::dcap::factory

staticprivate

Definition at line 9 of file outputHandlerDcap.h.

parPrefix

const std::string outputHandler::dcap::parPrefix

static

Definition at line 11 of file outputHandlerDcap.h.

---

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)