inputHandlerDummy.cpp

Go to the documentation of this file.

#include "inputHandlerDummy.h"
#include "block.h"
#include "copyRequestTypes.h"
#include "inputHandlerPosixFile.h"
#include "ewmscp.h"
#include "timer.h"
 
#include <fcntl.h>
#include <errMsgQueue.h>
#include <throwcall.h>
#include <unistd.h>
#include <random>
 
 
namespace inputHandler {
    decltype(dummy::factory) dummy::factory("dummy");
    defineStatic(dummy::nFiles, '\0',"dummyNFiles","number of files in the dummy dirs");
    defineStatic(dummy::nDirs, '\0',"dummyNDirs","number of subdirs in the dummy dirs");
    defineStatic(dummy::minSize, '\0',"dummyMinSize","minimum size of generated files",0);
    defineStatic(dummy::maxSize, '\0',"dummyMaxSize","minimum size of generated files",16*1024*1024);
    defineStatic(dummy::noCopy, '\0',"dummyNoCopy","just leave garbage in teh files blocks");
    defineStatic(dummy::mTime, genericStat::clock_type::now());
    
    const block& dummy::randomBlock() {
        static const block* data = nullptr;
        if (data == nullptr) {
            timerInst(createRandomBlock);
            auto buffer = new block(16*1024*1024);
            std::default_random_engine re;
            for (auto p=static_cast<decltype(re)::result_type*>(buffer->bufferAt(0));
                 p < static_cast<decltype(re)::result_type*>(buffer->bufferAt(buffer->max_size()/sizeof(*p)));
                 ++p) {
                *p = re();
            }
            buffer->bump_size(buffer->max_size());                              
            data = buffer;
        }
        return *data;
    }
 
    dummy::dummy() {
    }
    
    std::unique_ptr<base::reader> dummy::newReader(const std::string& aPath,
            copyRequest::stateType &state,
            const genericStat& inititalStat) {
        return std::unique_ptr<base::reader>(new readerDummy(aPath,
                                             state,
                                             inititalStat));
    }
 
 
 
 
 
    dummy::readerDummy::readerDummy(const std::string& /*aPath*/,
                                    copyRequest::stateType &/*state*/,
            const genericStat&inititalStat):
        ioHandle(),
        reader(inititalStat) {
    }
 
    dummy::readerDummy::~readerDummy() {
    }
 
 
 
    bool dummy::readerDummy::parallelizable() const {
        return true;
    }
    bool dummy::readerDummy::readBlock(block& b) {
        timerInst(read);
        b.clear(totalBytesRead);
        auto bytesToRead = readInitialStat.size - totalBytesRead;
        if (bytesToRead > b.max_size()) {
            bytesToRead = b.max_size();
        }
        if (! noCopy) {
            if (randomBlock().size() < bytesToRead) {
                throw std::runtime_error("random data block too small");
            }
            {
                timerInst(memcpy);
                memcpy(b.bufferAt(0), randomBlock().bufferAt(0), bytesToRead);
            }
        }
        b.bump_size(bytesToRead);
        totalBytesRead += bytesToRead;
        return totalBytesRead >= readInitialStat.size;
    }
 
 
    void dummy::readerDummy::readBlockP(block& b, size_t bytesToRead, off_t offset) {
        timerInst(readp);
        b.clear(offset);
        if (! noCopy) {
            if (randomBlock().size() < bytesToRead) {
                throw std::runtime_error("random data block too small");
            }
            {
                timerInst(memcpy);
                memcpy(b.bufferAt(0), randomBlock().bufferAt(0), bytesToRead);
            }
        }
        b.bump_size(bytesToRead);
    }
 
 
    void dummy::readerDummy::checkUnchangedness() {
    }
 
    std::unique_ptr<const genericStat> dummy::readerDummy::getStat() {
        return std::unique_ptr<const genericStat>(new genericStat(readInitialStat));
    }
 
    bool dummy::pathExists(const std::string&) {
        return true;
    }
    std::unique_ptr<const genericStat> dummy::getStat(const std::string& path,
        bool followLink) {
        if (path.find("/dummy/") == 0) {
            auto basename = path.substr(path.find_last_of('/')+1);
            auto stat = new genericStat;
            stat->device = 12345;
            if (basename.find("file_") == 0) {
                stat->mode = S_IFREG;
                stat->size = std::stoll(basename.substr(5));
                stat->mTime = mTime;
                stat->aTime = mTime;
                stat->blksize = randomBlock().max_size();
            } else {
                stat->mode = S_IFDIR;
            }
            return std::unique_ptr<const genericStat>(stat);
        } else { 
            static posixFileCommon posixHandler;
            return posixHandler.getStat(path, followLink);
        }
    }
    
    dummy::DummyDirectory::DummyDirectory(const std::string& aPath): Directory(aPath) {
        if (path.find("/dummy/") == 0) {
            auto basename = path.substr(path.find_last_of('/')+1);
            if (basename.empty()) { // tld
                level = 0;
            } else if (basename.find("dir_") == 0) {
                level = std::stoul(basename.substr(4));
            } else {
                throw std::logic_error(aPath + " is not a directory");
            }
            if (nFiles.size() <= level) {
                nFilesLeft = 0;
            } else {
                nFilesLeft = nFiles.at(level);
            }
            if (nDirs.size() <= level) {
                nDirsLeft = 0;
            } else {
                nDirsLeft = nDirs.at(level);
            }
        } else {
            throw std::logic_error("dummy directories mist start with /dummy/, not " + aPath);
        }
    }
    dummy::DummyDirectory::~DummyDirectory() noexcept(false) {
    }
    std::unique_ptr<base::Directory::Entry> dummy::DummyDirectory::getNextEntry(bool /*ignoreMissing*/) {
        if (nFilesLeft) {
            --nFilesLeft;
            std::string name("file_");
            auto stat = std::unique_ptr<genericStat>(new genericStat);
            std::uniform_int_distribution<size_t> distribution(minSize, maxSize);
            static std::default_random_engine rnd;
            stat->size = distribution(rnd);
            stat->device = 12345;
            stat->mode = S_IFREG;
            stat->blksize = randomBlock().max_size();
            stat->mTime = mTime;
            stat->aTime = mTime;
            name += std::to_string(stat->size);
            name += "_";
            name += std::to_string(nFilesLeft);
            return std::unique_ptr<Entry>(new Entry(name, stat));
        } else if (nDirsLeft) {
            --nDirsLeft;
            std::string name("dir_");
            auto stat = std::unique_ptr<genericStat>(new genericStat);
            stat->device = 12345;
            stat->mode = S_IFDIR;
            stat->mTime = mTime;
            stat->aTime = mTime;
            name += std::to_string(level+1);
            name += "_";
            name += std::to_string(nDirsLeft);
            return std::unique_ptr<Entry>(new Entry(name, stat));
        }
        return nullptr;
    }
    std::unique_ptr<base::Directory> dummy::getDirectory(const std::string& path) {
        if (path.find("/dummy/") == 0) {
            return std::unique_ptr<Directory>(new DummyDirectory(path));
        } else {
            static inputHandler::posixFile posixHandler;
            return posixHandler.getDirectory(path);
        }
    }
 
} //end namespace inputHandler