dcapCommon.cpp

Go to the documentation of this file.

#include "dcapCommon.h"
#include <OptionsChrono.h>
#include <forward_list>
#include "escapism.h"
 
static const std::string parPrefix("dCap");
 
class dCapConfigParameter {
    static std::forward_list<dCapConfigParameter*>& getList() {
        static std::remove_reference<decltype(getList())>::type list;
        return list;
    }
  protected:
    virtual void applySingle() = 0;
  public:
    virtual void fForbid(options::base& /*opt*/) {};
    dCapConfigParameter() {
        getList().push_front(this);
    }
    static void apply() {
        for (auto par : getList()) {
            par->applySingle();
        }
    }
};
template <class T> class dCapCfgPar: public dCapConfigParameter {
    options::single<T> option;
    void (* set)(T);
  public:
    dCapCfgPar(const std::string& optName,
               const std::string& description,
               void (* setter)(T)):
        option('\0', parPrefix + optName, description),
        set(setter) {
    }
    void fForbid(options::base& opt) override {
        opt.fForbid(&option);
        option.fForbid(&opt);
    };
    void applySingle() override {
        if (option.fIsSet()) {
            set(option);
        }
    }
};
template <> class dCapCfgPar<const char*>: public dCapConfigParameter {
    options::single<std::string> option;
    void (* set)(const char *);
  public:
    dCapCfgPar(const std::string& optName,
               const std::string& description,
               void (* setter)(const char*)):
        option('\0', parPrefix + optName, description),
        set(setter) {
    }
    void applySingle() override {
        if (option.fIsSet()) {
            set(option.c_str());
        }
    }
};
template <class T, class U> class dCapCfg2Par: public dCapConfigParameter {
    options::single<T> option1;
    options::single<U> option2;
    void (* set)(T, U);
  public:
    dCapCfg2Par(const std::string& opt1Name,
                const std::string& description1,
                const std::string& opt2Name,
                const std::string& description2,
                void (* setter)(T, U),
                std::initializer_list<dCapConfigParameter*> forbid = {}):
        option1('\0', parPrefix + opt1Name, description1),
        option2('\0', parPrefix + opt2Name, description2),
        set(setter) {
        option1.fRequire(&option2);
        option2.fRequire(&option1);
        for (auto& other : forbid) {
            other->fForbid(option1);
            other->fForbid(option2);
        }
    }
    void applySingle() override {
        if (option1.fIsSet()) {
            set(option1, option2);
        }
    }
};
template <typename T> class dCapCfgTimePar: public dCapConfigParameter {
    options::single<std::chrono::seconds> option;
    void (* set)(T);
  public:
    dCapCfgTimePar(const std::string& optName,
                   const std::string& description,
                   void (* setter)(T)):
        option('\0', parPrefix + optName, description),
        set(setter) {
    }
    void applySingle() override {
        if (option.fIsSet()) {
            set(option.count());
        }
    }
};
 
static dCapCfgPar<unsigned short> CallbackPort("CallbackPort", "set callback port", dc_setCallbackPort);
static dCapCfg2Par<unsigned short, unsigned short>
CallbackPortRange("CallbackPortRangeBegin", "set callback port range begin",
                  "CallbackPortRangeEnd", "set callback port range end",
                  dc_setCallbackPortRange, {&CallbackPort});
static dCapCfgPar<const char*> ReplyHostName("ReplyHostName", "set reply host name", dc_setReplyHostName);
static dCapCfgPar<const char*> Tunnel("Tunnel", "set tunnel", dc_setTunnel);
static dCapCfgPar<const char*> TunnelType("TunnelType", "set tunnel type", dc_setTunnelType);
static dCapCfgPar<unsigned int> DebugLevel("DebugLevel", "set debug level", dc_setDebugLevel);
static dCapCfgTimePar<time_t> OpenTimeout("OpenTimeout", "set open timeout", dc_setOpenTimeout);
static dCapCfgTimePar<unsigned int> CloseTimeout("CloseTimeout", "set close timeout", dc_setCloseTimeout);
 
 
dcapCommon::dcapCommon() {
    dCapConfigParameter::apply();
}
 
 
decltype(dCapLock::extraOptionMutex) dCapLock::extraOptionMutex;
 
 
std::string dcapCommon::fixPathUrl(const std::string& path) {
    // example path: dcap://dcache-dot3:22125/pnfs/desy.de/dot/data_volatile/cards/A Display of My Dark Power.full.jpg
    auto index = path.find("//"); //find host name start
    if (index == std::remove_reference<decltype(path)>::type::npos) {
        throw std::runtime_error("can't sanitize path \"" + path + "\"");
    }
    index = path.find('/', index + 2); // find start of real path part
    std::string url(path.substr(0, index + 1));
    static const auto escaper = escapism::newEscaper("Urlsoft");
    escaper->escape(path.substr(index + 1), url);
    if (url.back() == '/') {
        url.pop_back();
    }
    return url;
}
 
 
 
 
bool dcapCommon::pathExists(const std::string& path) {
    dCapLock extraOptionLock;
    struct dcapStat statBuf;
    std::string fixedPath(fixPathUrl(path));
    auto result = dc_stat(fixedPath.c_str(), &statBuf);
    if (result && errno == ENOENT) {
        return false;
    }
    throwcall::dcap::good0(result, "can't stat ", fixedPath);
    return true;
};
std::unique_ptr<const genericStat> dcapCommon::getStat(const std::string& path,
        bool followLink) {
    dCapLock extraOptionLock;
    struct dcapStat statBuf;
    std::string fixedPath(fixPathUrl(path));
    int result;
    if (followLink) {
        result = dc_stat(fixedPath.c_str(), &statBuf);
    } else {
        result = dc_lstat(fixedPath.c_str(), &statBuf);
    }
    if (result && errno == ENOENT && (dc_errno == DEOK || dc_errno == DESRVMSG)) {
        return nullptr;
    }
    throwcall::dcap::good0(result, "can't stat ", fixedPath);
    if (statBuf.st_blksize == 0) { // we got nonsense
        statBuf.st_blksize = 1024 * 1024; // use 1M as default
    }
    return std::unique_ptr<const genericStat>(new genericStat(statBuf, std::chrono::seconds(1)));
};
 
 
 
 
dcapIoCommon::dcapIoCommon(const std::string& aPath):
    path(dcapCommon::fixPathUrl(aPath)) {
}
 
 
 
 
 
std::unique_ptr<const genericStat> dcapIoCommon::getStat() {
    dCapLock extraOptionLock;
    struct dcapStat statBuf;
    throwcall::dcap::good0(dc_fstat(fd, &statBuf), "can't stat", path);
    return std::unique_ptr<const genericStat>(new genericStat(statBuf, std::chrono::seconds(1)));
}