outputHandlerDaosFs.h

Go to the documentation of this file.

#ifndef __outputHandlerDaosFs_h__
#define __outputHandlerDaosFs_h__
#include "outputHandler.h"
#include "daosFsCommon.h"
#include <sys/stat.h>
#include <sys/types.h>
 
namespace outputHandler {
 
    class daosFs: public base, virtual public daosFsCommon {
        static factoryTemplate<daosFs> factory;
      public:
        class writerDaosFs: public writer, virtual public daosFsIoCommon {
          protected:
            struct stat writeInitialStat;
            std::unique_ptr<ioHandle::attrDataType> attrData;
            std::unique_ptr<acl::list> aclData;
          public:
            writerDaosFs(const std::string& aPath,
                            bool mightAppend,
                            size_t sourceSize,
                            size_t readBlockSize,
                            copyRequest::stateType &state,
                            bool noWrite,
                            std::unique_ptr<ioHandle::attrDataType> aAttrData,
                         std::unique_ptr<acl::list> aAclData,
                         daosFs& aHandler);
            writerDaosFs(std::string& aPath,
                            bool noWrite,
                            std::unique_ptr<ioHandle::attrDataType> aAttrData,
                            std::unique_ptr<acl::list> aAclData,
                         daosFs& aHandler);
            void closeAndRemoveBadCopy() override;
            ~writerDaosFs() noexcept(false) override;
            void seek(size_t position) override;
            bool parallelizable() const override;
            size_t getSize() const override;
            void writeBlock(const block& b) override;
            void writeBlockP(const block& b) override;
            void doAttributePreservations(const genericStat& readInitialStat) override;
            void sync() override;
        };
        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;
    };
}; // end namespace outputHandler
 
 
#endif