outputHandler::daosFs Class Reference

#include <outputHandlerDaosFs.h>

Inheritance diagram for outputHandler::daosFs:

Collaboration diagram for outputHandler::daosFs:

Classes
class	writerDaosFs

Public Member Functions
	daosFs ()=default
	~daosFs () 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 > attrData, std::unique_ptr< acl::list > aclData) override
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) 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	createSymlink (const std::vector< char > &target, const std::string &path, uid_t uid, gid_t gid) override
void	doAttributePreservations (const std::string &path, const genericStat &stat) override
size_t	getMaxNameLength (const std::string &dirPath) override
Public Member Functions inherited from outputHandler::base
	~base () override=default
template<class C >
void	shortenNameToMax (const std::string &path, C &pathBuf, const std::string &suffix)
Public Member Functions inherited from pathHandler
virtual	~pathHandler ()=default
Public Member Functions inherited from daosFsCommon
dfs_obj_t *	getDirObj (const std::string &path)
	daosFsCommon (daosOptions &aOpt, bool isWriter)
	~daosFsCommon () override
bool	pathExists (const std::string &path) override
std::unique_ptr< const genericStat >	getStat (const std::string &path, bool followLink) override
std::string	getXattr (const std::string &path, const std::string &name) override

Static Private Attributes
static factoryTemplate< daosFs >	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)
Public Attributes inherited from daosFsCommon
daos_handle_t	poh
daos_handle_t	coh
dfs_t *	dfs
int	flags
std::map< std::string, dfs_obj_t * >	pathMap
Protected Member Functions inherited from outputHandler::base
	base ()=default
Static Protected Member Functions inherited from outputHandler::base
static std::map< std::string, factoryClass * > &	getFactoryMap ()
Protected Attributes inherited from daosFsCommon
daosOptions &	opt

Detailed Description

Definition at line 10 of file outputHandlerDaosFs.h.

Constructor & Destructor Documentation

daosFs()

outputHandler::daosFs::daosFs ( )

default

~daosFs()

outputHandler::daosFs::~daosFs ( )

overridedefault

Member Function Documentation

createSymlink()

void outputHandler::daosFs::createSymlink ( const std::vector< char > &  target, const std::string &  path, uid_t  uid, gid_t  gid  )

overridevirtual

Reimplemented from outputHandler::base.

Definition at line 215 of file outputHandlerDaosFs.cpp.

                                                        {
        timerInst(symlink);
        auto retval = symlink(target.data(), path.c_str());
        if (retval != 0 && errno != EEXIST) {
            throwcall::good0(retval, "can't create link at ", path);
        }
        if (static_cast<std::make_signed<decltype(gid)>::type>(gid) != -1
                || static_cast<std::make_signed<decltype(uid)>::type>(uid) != -1) {
            throwcall::good0(lchown(path.c_str(), uid, gid), "can't set owner/group (", uid, ",", gid, ") on ", path);
        }
    }

References gid, throwcall::good0(), timerInst, and uid.

Here is the call graph for this function:

doAttributePreservations()

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

overridevirtual

Reimplemented from outputHandler::base.

Definition at line 425 of file outputHandlerDaosFs.cpp.

                                     {
        if (preserve.timestamps) {
            struct timespec times[2];
            times[0].tv_nsec = UTIME_OMIT; // leave atime unchanged
            stat.getMtime(times[1]);
            timerInst(utimensat);
            throwcall::good0(utimensat(0, path.c_str(), times, 0), "can't set mtime on ", path);
        }
        if (preserve.mode) {
            timerInst(chmod);
            throwcall::good0(chmod(path.c_str(), stat.mode), "can't set mode of ", path);
        } else {
            auto oldmask = umask(0);
            timerInst(chmod);
            throwcall::good0(chmod(path.c_str(), modeBits & ~oldmask), "can't set mode of ", path);
            umask(oldmask);
        }
 
        if (gid != -1 || uid != -1) {
            timerInst(chown);
            throwcall::good0(chown(path.c_str(), uid, gid), "can't set owner/group (", uid, ",", gid, ") of ", path);
        } else if (preserve.ownership) {
            timerInst(chown);
            throwcall::good0(chown(path.c_str(), stat.ownerUid, stat.ownerGid),
                             "can't set owner/group (", stat.ownerUid, ",", stat.ownerGid, ") of ",
                             path);
        }
    }

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

Here is the call graph for this function:

ensureParentDirs()

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

overridevirtual

Implements outputHandler::base.

Definition at line 53 of file outputHandlerDaosFs.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 stat statbuf;
 
        if (stat(dir.c_str(), &statbuf)) {
            if (errno == ENOENT || errno == ENOTDIR) {
                ensureParentDirs(dir, srcPath, InputHandler);
                static timer::anchor A("mkdir");
                timer::instanceUnscoped I(A);
                auto result = mkdir(dir.c_str(), 0777u);
                I.stop(slownessThreshold, dir);
 
                if (result != 0 && errno == EEXIST) {
                    return; // we lost a race with another copy process...
                }
 
                throwcall::good0(result, "can't create directory ", dir);
 
                if (gid != -1 || uid != -1) {
                    timerInst(chown);
                    throwcall::good0(chown(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");
        }
        if (requiredFsid != 0) {
            struct statvfs fsstat;
            timerInst(statvfs);
            throwcall::good0(statvfs(dir.c_str(), &fsstat), "can't statvfs ", dir);
            if ((fsstat.f_fsid & fsidMask) != requiredFsid) {
                throw fatalException("wrong fs id 0x", std::hex, fsstat.f_fsid, " instead of ", requiredFsid);
            }
        }
    }

References errMsg::emit(), outputHandler::fsidMask, gid, throwcall::good0(), errMsg::info, outputHandler::requiredFsid, outputHandler::slownessThreshold, timer::instanceUnscoped::stop(), timerInst, and uid.

Here is the call graph for this function:

getMaxNameLength()

size_t outputHandler::daosFs::getMaxNameLength ( const std::string &  dirPath )

overridevirtual

Reimplemented from outputHandler::base.

Definition at line 455 of file outputHandlerDaosFs.cpp.

                                                            {
        errno = 0;
        timerInst(pathconf);
        return throwcall::badval(pathconf(dirPath.c_str(), _PC_NAME_MAX), -1,"can't get max name lenght on", dirPath);
    }

References throwcall::badval(), and timerInst.

Here is the call graph for this function:

newTmpWriter()

std::unique_ptr< base::writer > outputHandler::daosFs::newTmpWriter ( std::string &  path, size_t  sourceSize, bool  noWrite, std::unique_ptr< ioHandle::attrDataType >  attrData, std::unique_ptr< acl::list >  aclData  )

overridevirtual

Reimplemented from outputHandler::base.

Definition at line 36 of file outputHandlerDaosFs.cpp.

                                            {
        return std::unique_ptr<base::writer>(new writerDaosFs(path,
                                                                 noWrite,
                                                                 std::move(attrData),
                                                                 std::move(aclData),
                                                                 *this));
    }

newWriter()

std::unique_ptr< base::writer > outputHandler::daosFs::newWriter ( const std::string &  path, 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  )

overridevirtual

Implements outputHandler::base.

Definition at line 20 of file outputHandlerDaosFs.cpp.

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

remove()

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

overridevirtual

Implements outputHandler::base.

Definition at line 95 of file outputHandlerDaosFs.cpp.

                                                                          {
        struct stat dsttat;
        {
            timerInst(lstat);
            auto retval = lstat(path.c_str(), &dsttat);
 
            if (retval && errno == ENOENT) {
                state |= copyRequest::stateBitType::vanished;
                return;
            }
        }
        if (S_ISDIR(dsttat.st_mode)) {
            timerInst(rmdir);
            auto retval = rmdir(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::good0(retval, "can't remove directory ", path);
            } else {
                state |= copyRequest::stateBitType::done;
                return;
            }
        } else {
            timerInst(unlink);
            auto retval = unlink(path.c_str());
 
            if (retval && errno == ENOENT) {
                state |= copyRequest::stateBitType::vanished;
            } else {
                throwcall::good0(retval, "can't unlink ", path);
            }
            state |= copyRequest::stateBitType::done;
        }
    }

References copyRequest::done, errMsg::emit(), copyRequest::failed, throwcall::good0(), errMsg::info, timerInst, and copyRequest::vanished.

Here is the call graph for this function:

rename()

base::renameRetvalType outputHandler::daosFs::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 151 of file outputHandlerDaosFs.cpp.

                                         {
        struct stat fromPathStatBuf;
        static timer::anchor A("stat");
        timer::instanceUnscoped I(A);
        auto statRetVal = stat(fromPath.c_str(), &fromPathStatBuf);
        I.stop();
        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::good0(statRetVal, "can't stat '", fromPath, "'");
            return base::renameRetvalType::cantHappen; // never reached
        }
        genericStat fromPathStat(fromPathStatBuf, std::chrono::nanoseconds(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
            if (readInitialStat) {
                std::string initialTime;
                std::string finalTime;
                readInitialStat->getMtime(initialTime);
                fromPathStat.getMtime(finalTime);
                errMsg::emit(errMsg::level::info, errMsg::location(),
                             fromPath, "move"
                             "file (", toPath, ") changed unexpectedly ("
                             , initialTime, " -> ", finalTime, ", "
                             , readInitialStat->size, " -> ", fromPathStat.size
                             , ", doing fresh copy");
            } else {
                errMsg::emit(errMsg::level::info, errMsg::location(),
                             fromPath, "move",
                             "file (", toPath, ") has no initial stat, doing fresh copy");
            }
            return base::renameRetvalType::fileChanged;
        } else { // try to move the existing copy
            timerInst(rename);
            auto retval = std::rename(fromPath.c_str(), 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::good0(retval, "can't rename '", fromPath, "' to '", toPath, "'");
                state |= copyRequest::stateBitType::done;
                return base::renameRetvalType::ok;
            }
        }
    }

References outputHandler::base::cantHappen, copyRequest::done, errMsg::emit(), outputHandler::base::fileChanged, outputHandler::base::fileVanished, genericStat::getMtime(), throwcall::good0(), copyRequest::ignore, errMsg::info, genericStat::isDir(), genericStat::isSameMtimeAs(), outputHandler::base::ok, genericStat::size, timer::instanceUnscoped::stop(), and timerInst.

Referenced by renameSimple().

Here is the call graph for this function:

Here is the caller graph for this function:

renameSimple()

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

overridevirtual

Implements outputHandler::base.

Definition at line 139 of file outputHandlerDaosFs.cpp.

                                                          {
        timerInstTO(rename,slownessThreshold,fromPath);
        auto retval = std::rename(fromPath.c_str(), toPath.c_str());
        if (retval && (errno == ENOENT || errno == ENOTDIR)) {
            return false;
        }
        throwcall::good0(retval, "can't rename '", fromPath, "' to '", toPath, "'");
        return true;
    }

References throwcall::good0(), rename(), outputHandler::slownessThreshold, and timerInstTO.

Here is the call graph for this function:

Member Data Documentation

factory

factoryTemplate<daosFs> outputHandler::daosFs::factory

staticprivate

Definition at line 11 of file outputHandlerDaosFs.h.

---

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)