daosFsCommon.cpp

Go to the documentation of this file.

#include "daosFsCommon.h"
#include "genericStat.h"
#include "ewmscp.h"
#include "timer.h"
#include <throwcall.h>
#include <errMsgQueue.h>
#include <fcntl.h>
 
#ifndef ENOATTR
#define ENOATTR ENODATA
#endif
 
daosFsCommon::daosOptions::daosOptions(const std::string& optPrefix):
    containerName('\0', optPrefix + "_container", "container name to use"),
    poolName('\0', optPrefix + "_pool", "pool name to use"),
    sysName('\0', optPrefix + "_sys", "sys name to use")
{
}
 
 
dfs_obj_t* daosFsCommon::getDirObj(const std::string& path) {
    auto stripped = path.substr(0,path.find_last_of('/'));
    auto it = pathMap.find(path);
    if (it == pathMap.end()) {
        dfs_obj_t* obj;
        timerInst(dfs_lookup);
        throwcall::good0(dfs_lookup(dfs, path.c_str(), flags, &obj, nullptr, nullptr),"can't lookup path", path); 
        auto result = pathMap.emplace(path, obj);
        it = result.first;
    }
    return it->second;
}
 
daosFsCommon::daosFsCommon(daosOptions& aOpt, bool isWriter): flags(isWriter ? O_RDWR : O_RDONLY), opt(aOpt) {
    throwcall::good0(daos_pool_connect(opt.poolName.c_str(), opt.sysName.empty() ? nullptr : opt.sysName.c_str(), 0,
                                       &poh, nullptr, nullptr),
                     "can't connect to pool ", opt.poolName, " on sys ", opt.sysName);
    throwcall::good0(daos_cont_open(poh, opt.containerName.c_str(), 0,
                                    &coh, nullptr, nullptr),
                     "can't open container ", opt.containerName, " in pool ", opt.poolName, " on sys ", opt.sysName);
    throwcall::good0(dfs_mount(poh, coh, flags, &dfs),
                     "can't mount daos fs in containr ", opt.containerName, " in pool ", opt.poolName, " on sys ", opt.sysName);
}
daosFsCommon::~daosFsCommon() {
    for (auto& item: pathMap) {
        throwcall::good0(dfs_release(item.second),
                         "can't release dir object for ", item.first);
    }
    throwcall::good0(dfs_umount(dfs),
                     "can't umount daos fs in containr ", opt.containerName, " in pool ", opt.poolName, " on sys ", opt.sysName);
    throwcall::good0(daos_cont_close(coh, nullptr),
                     "can't close container ", opt.containerName, " in pool ", opt.poolName, " on sys ", opt.sysName);
    throwcall::good0(daos_pool_disconnect(poh, nullptr),
                     "can't disconnect pool ", opt.poolName, " on sys ", opt.sysName);
}
 
 
bool daosFsCommon::pathExists(const std::string& path) {
    struct stat statBuf;
    timerInst(stat);
    auto result = dfs_stat(dfs, getDirObj(path), path.c_str(), &statBuf);
    if (result && (errno == ENOENT || errno == ENOTDIR)) {
        return false;
    }
    throwcall::good0(result, "can't stat ", path);
    return true;
};
std::unique_ptr<const genericStat> daosFsCommon::getStat(const std::string& path,
        bool followLink) {
    struct stat statBuf;
    timerInst(stat);
    auto result = dfs_stat(dfs, getDirObj(path), path.c_str(), &statBuf);
    if (result && errno == ENOENT) {
        return nullptr;
    }
    throwcall::good0(result, "can't stat", path);
    if (followLink && S_ISLNK(statBuf.st_mode)) {
        char buf[4096];
        daos_size_t size = sizeof(buf);
        dfs_obj_t* obj;
        throwcall::good0(dfs_open(dfs, getDirObj(path), path.c_str(), 0x666, O_RDONLY, 0, 0, nullptr, &obj),
                         "can't open link", path);
        throwcall::good0(dfs_get_symlink_value(obj, buf, &size),
                         "can't get symlink of link ", path);
        throwcall::good0(dfs_release(obj), "can't  relaese ",path);
        return getStat(buf, true);
    }
    return std::unique_ptr<const genericStat>(new genericStat(statBuf, std::chrono::nanoseconds(1)));
};
 
 
std::string daosFsCommon::getXattr(const std::string& path,
                                      const std::string& name) {
    char buffer[512];
 
    dfs_obj_t* obj;
    throwcall::good0(dfs_lookup(dfs, path.c_str(), flags,
                                &obj, nullptr, nullptr),
                     "can't lookup ", path);
    timerInst(getxattr);
    daos_size_t size = sizeof(buffer);
    auto retval = dfs_getxattr(dfs, obj, name.c_str(), buffer, &size);
    throwcall::good0(dfs_release(obj),"can't release ", path);
    if (retval == -1) {
        if (errno == ENOENT || errno == ENOATTR) {
            return "";
        }
        throwcall::badval(retval, -1, "can't get xattr on ", path);
    }
    buffer[size] = '\0';
    return buffer;
};
 
 
daosFsIoCommon::daosFsIoCommon(const std::string& aPath, daosFsCommon& aHandler):
                                                                  path(aPath),
                                                                  obj(nullptr),
                                                                  handler(aHandler){
}
 
 
 
std::unique_ptr<const genericStat> daosFsIoCommon::getStat() {
    struct stat statBuf;
    timerInst(stat);
    throwcall::good0(dfs_ostat(handler.dfs, obj, &statBuf), "can't stat", path);
    return std::unique_ptr<const genericStat>(new genericStat(statBuf, std::chrono::nanoseconds(1)));
}
void daosFsIoCommon::setXattr(const std::string& name, const std::string& value) {
    timerInst(setxattr);
    throwcall::good0(dfs_setxattr(handler.dfs, obj, name.c_str(), value.data(), value.size(), 0),
                     "can't set xattr '", name, "' to '", value, "' on ", path);
}
 
std::string daosFsIoCommon::getXattr(const std::string& name) {
    char buffer[512];
    timerInst(getXattr);
    daos_size_t size = sizeof(buffer);
    auto retval = dfs_getxattr(handler.dfs, obj, name.c_str(), buffer, &size);
    if (retval != 0) {
        if (errno != ENOATTR) {
            throwcall::badval(retval, -1, "can't read xattr '", name, "' from ", path);
        }
        return "";
    } else {
        buffer[size] = '\0';
    }
    return buffer;
}
 
void daosFsIoCommon::removeXattr(const std::string& name) {
    timerInst(removexattr);
    auto result = dfs_removexattr(handler.dfs, obj,  name.c_str());
    if (result && errno == ENOATTR) {
        return; // be silent about this
    }
    throwcall::good0(result,
                     "can't remove xattr ", name, " from ", path);
}
 
void daosFsIoCommon::attrDataType::add(const std::string& name, const std::string& value) {
    xattrs.emplace_front(name, value);
}
void daosFsIoCommon::attrDataType::set(ioHandle* handle) {
    for (const auto& item : xattrs) {
        handle->setXattr(item.first, item.second);
    }
}
 
void daosFsIoCommon::attrDataType::fill(daosFsIoCommon& aHandler) {
    char buf[0x10000];
    static timer::anchor la("listxattr");
    timer::instanceUnscoped li(la);
    daos_size_t size(sizeof(buf));
    throwcall::good0(dfs_listxattr(aHandler.handler.dfs, aHandler.obj, buf, &size),
                                     "can't get xattrs for ", aHandler.path);
    li.stop();
    for (auto readPtr = &buf[0]; readPtr < &buf[size];) {
        add(readPtr, aHandler.getXattr(readPtr));
        while (*readPtr++);
    }
}
 
std::unique_ptr<ioHandle::attrDataType> daosFsIoCommon::getAttrData(const outputHandler::base* /*aOutputHandler*/) {
    auto attrData = std::unique_ptr<attrDataType>(new attrDataType());
    attrData->fill(*this);
    if (attrData->xattrs.empty()) {
        return nullptr;
    }
    #if __GNUC__ >= 8
    return attrData;
    #else
    return std::move(attrData);
    #endif
}