outputHandler.h

Go to the documentation of this file.

#ifndef __outputHandler_h__
#define __outputHandler_h__
 
#include "ioHandle.h"
#include "pathHandler.h"
#include "inputHandler.h"
#include <map>
#include <vector>
#include <memory>
#include <unwindCheck.h>
class block;
namespace copyRequest {
    class stateType;
};
 
namespace outputHandler {
    class base: virtual public pathHandler {
        // now follows some reflection magic
      public:
        class factoryClass;
      protected:
        static std::map<std::string, factoryClass*>& getFactoryMap() {
            static std::remove_reference<decltype(getFactoryMap())>::type map;
            return map;
        }
      public:
        class factoryClass {
          protected:
            const std::string name;
            factoryClass(const std::string& aName):
                name(aName) {
                getFactoryMap()[name] = this;
            }
          public:
            virtual base* create() const = 0;
        };
        template <class T> class factoryTemplate: public factoryClass {
          public:
            factoryTemplate(const std::string& aName): factoryClass(aName) {};
            base* create() const override {
                return new T();
            }
        };
        // end of reflection magic
      protected:
        base() = default;
      public:
        ~base() override = default;
 
        class writer: protected unwindCheck, virtual public ioHandle {
        public:
            writer() = default;
            virtual ~writer() = default;
            virtual void closeAndRemoveBadCopy() = 0;
            virtual void seek(size_t position);
            virtual size_t getSize() const;
            virtual void writeBlock(const block& b) = 0;
            virtual void writeBlockP(const block& /*b*/) {
                throw unimplementedActionError("parallel writing not implemented");
            }
            virtual void doAttributePreservations(const genericStat& readInitialStat) = 0;
            virtual void sync() = 0;
        };
 
        virtual 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) = 0;
        virtual 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);
        static base* newHandler(const std::string& name) {
            auto it = getFactoryMap().find(name);
            if (it != getFactoryMap().end()) {
                return it->second->create();
            }
            throw std::runtime_error("no outputHandler factory called " + name);
        }
        template <class T> static void addAllowedNamesToOption(T& option) {
            for (const auto& item : getFactoryMap()) {
                option.fAddToRange(item.first);
            }
        };
 
        // methods to abstract some file handling
        virtual void ensureParentDirs(const std::string& path,
                                      const std::string& srcPath,
                                      inputHandler::base* InputHandler) = 0;
        virtual void remove(const std::string& path, copyRequest::stateType &state) = 0;
        virtual bool renameSimple(const std::string& fromPath,
                                  const std::string& toPath) = 0;
        virtual void createSymlink(const std::vector<char>& /*target*/,
                                   const std::string& /*path*/,
                                   uid_t /*uid*/, gid_t /*gid*/) {
            throw unimplementedActionError("symlink creation not implemented");
        }
 
        enum class renameRetvalType {
            ok,
            fileChanged,
            fileVanished,
            cantHappen
        };
 
        virtual renameRetvalType rename(const std::string& fromPath,
                                        const std::unique_ptr<const genericStat>& readInitialStat,
                                        const std::string& toPath,
                                        copyRequest::stateType& state) = 0;
        virtual void doAttributePreservations(const std::string& /*path*/,
                                              const genericStat& /*stat*/) {
            throw unimplementedActionError("setMtime not implemented");
        }
        virtual size_t getMaxNameLength(const std::string& dirPath);
        template <class C> void shortenNameToMax(const std::string& path,
                                                 C& pathBuf,
                                                 const std::string& suffix) {
            auto lastSlash = path.find_last_of('/');
            std::string dirPath;
            size_t fileNameLength;
            if (lastSlash != std::string::npos) {
                fileNameLength = path.size() - lastSlash - 1;
                dirPath = path.substr(0,lastSlash);
            } else {
                fileNameLength = path.size();
                dirPath="./";
            }
            if (fileNameLength + suffix.size() > getMaxNameLength(dirPath)) {
                pathBuf.resize(path.size() - suffix.size());
            }
        }
    };
}; // end namespace outputHandler
#endif