davixCommon.h

Go to the documentation of this file.

#ifndef __davixCommon_h__
#define __davixCommon_h__
#include "copyRequestTypes.h"
#include "ioHandle.h"
#include "pathHandler.h"
#include <OptionsChrono.h>
#include <davix.hpp>
 
class errorReport {
    static options::single<bool> withTiming;
    Davix::DavixError* report;
    copyRequest::clock_type::time_point start;
    const std::string func;
    const std::string what;
    const std::string& path;
  public:
    errorReport(const std::string& aFunc,
                const std::string& aWhat,
                const std::string& aPath): report(nullptr),
        start(std::chrono::system_clock::now()),
        func(aFunc),
        what(aWhat),
        path(aPath) {
    };
    operator Davix::DavixError** () {
        return &report;
    }
    Davix::DavixError* operator->() {
        if (report == nullptr) {
            throw std::runtime_error("no davix error set");
        }
        return report;
    }
    const std::string& getMessage() const {
        if (report == nullptr) {
            static const std::string noMessageYet("no davix eror set");
            return noMessageYet;
        } else {
            return report->getErrMsg();
        }
    }
    void throwUp() {
        if (report == nullptr) {
            throw std::runtime_error(func + " "
                                     + what + " on "
                                     + path + " : no davix error set");
        }
        throw std::runtime_error(func + " "
                                 + what + " on "
                                 + path + " : "
                                 + report->getErrMsg());
    }
    ~errorReport() {
        Davix::DavixError::clearError(&report);
        if (withTiming) {
            auto now = copyRequest::clock_type::now();
            auto dt = std::chrono::duration_cast<std::chrono::duration<double>>(now - start).count();
            std::cerr << func << ":" <<  what << ": " << std::fixed << dt << "\n";
        }
    }
};
 
template <class T> class davixCfgPar {
    options::single<T> option;  
    void (Davix::RequestParams::* set)(T); 
  public:
    davixCfgPar(const std::string& parPrefix,
                const std::string& optName,
                const std::string& description,
                void (Davix::RequestParams::* setter)(T)):
        option('\0', parPrefix + optName, description),
        set(setter) {
    }
    davixCfgPar(const std::string& parPrefix,
                const std::string& optName,
                const std::string& description,
                void (Davix::RequestParams::* setter)(T),
                T aDefault):
        option('\0', parPrefix + optName, description, aDefault),
        set(setter) {
    }
    void applySingle(Davix::RequestParams& params) {
        if (option.fIsSet()) {
            (params.*set)(option);
        }
    }
};
 
template <> class davixCfgPar<struct timespec*> {
        options::single<std::chrono::nanoseconds> option;
        void (Davix::RequestParams::* set)(struct timespec*);
        struct timespec spec;
public:
        davixCfgPar(const std::string& parPrefix,
                    const std::string& optName,
                    const std::string& description,
                    void (Davix::RequestParams::* setter)(struct timespec*)):
            option('\0', parPrefix + optName, description),
            set(setter) {
        }
        void applySingle(Davix::RequestParams& params) {
            if (option.fIsSet()) {
                spec.tv_sec = std::chrono::duration_cast<std::chrono::seconds>(option).count();
                spec.tv_nsec = option.count() % 1000000000;
                (params.*set)(&spec);
            }
        }
    };
 
template <class T> class davixCfgEnum {
    options::single<std::string> option;
    void (Davix::RequestParams::* set)(T);
    std::map<std::string, T> nameMap;
  public:
    davixCfgEnum(const std::string& parPrefix,
                 const std::string& optName,
                 const std::string& description,
                 void (Davix::RequestParams::* setter)(T),
                 const std::map<std::string, T> map):
        option('\0', parPrefix + optName, description),
        set(setter),
        nameMap(map) {
        for (const auto& item : nameMap) {
            option.fAddToRange(item.first);
        }
    }
    void applySingle(Davix::RequestParams& params) {
        if (option.fIsSet()) {
            (params.*set)(nameMap.at(option));
        }
    }
};
 
template <class T> class davixCfgStrings {
    options::container<std::string> option;
    void (Davix::RequestParams::* set)(T);
  public:
    davixCfgStrings(const std::string& parPrefix,
                    const std::string& optName,
                    const std::string& description,
                    void (Davix::RequestParams::* setter)(T)):
        option('\0', parPrefix + optName, description),
        set(setter) {
    }
    void applySingle(Davix::RequestParams& params) {
        for (const auto& item : option) {
            (params.*set)(item);
        }
    }
};
 
class davixCfgX509 {
    options::single<std::string> p12Path;
    options::single<std::string> privKeyPath;
    options::single<std::string> credentialPath;
    options::single<std::string> proxy;
    Davix::X509Credential credential;
  public:
    davixCfgX509(const std::string& parPrefix);
    void applySingle(Davix::RequestParams& params, bool &accessConfigDone);
};
 
class davixConfigObject {
 
    // cfg members:
    davixCfgEnum<const Davix::RequestProtocol::Protocol>    Protocol;
    davixCfgX509 X509Cert;
    davixCfgStrings<const std::string&> CertificateAuthorityPath;
    davixCfgPar<bool> SSLCAcheck;
    davixCfgPar<int> OperationRetry;
    davixCfgPar<struct timespec*> OperationTimeout;
    davixCfgPar<struct timespec*> ConnectionTimeout;
public:
    options::single<bool> noAuth;
private:
    bool accessConfigDone;
 
 
  public:
    davixConfigObject(const std::string& parPrefix);
    void apply(Davix::RequestParams& params);
    bool accessConfigured() const;
};
 
 
 
class davixCommon: virtual public pathHandler {
  protected:
    Davix::Context context;
  public:
    Davix::RequestParams params;
    Davix::DavPosix posix;
  protected:
    std::string loginName;
    std::string passWord;
    static int loginCallback(void* userdata,
                             const Davix::SessionInfo & info,
                             std::string & login,
                             std::string & password,
                             int count,
                             Davix::DavixError** err);
    int loginCallbackInner(std::string & login,
                           std::string & password,
                           int count);
 
 
  public:
    davixCommon(davixConfigObject& configObj);
    static void getPassword(const std::string& prompt,
                            std::string& password);
 
  public:
    bool pathExists(const std::string& path) override;
    std::unique_ptr<const genericStat> getStat(const std::string& path,
            bool followLink) override;
};
 
class davixIoCommon: virtual public ioHandle {
  protected:
    const std::string& path;
    davixCommon& handler;
    DAVIX_FD* fd;
  public:
    davixIoCommon(const std::string& aPath, davixCommon& aHandler);
    std::unique_ptr<const genericStat> getStat() override;
};
 
 
#endif