cmdLineRequestProvider.cpp

Go to the documentation of this file.

#include "cmdLineRequestProvider.h"
#include "scoped.h"
#include "throwcall.h"
#include "escapism.h"
#include "timer.h"
#include <errMsgQueue.h>
 
defineStatic(cmdLineRequestProvider::dereferenceCmdLine, 'H', "derefCmdLine",
             "follow command-line symbolic links in SOURCE", false);
defineStatic(cmdLineRequestProvider::recursive, 'R', "recursive",
             "treat directories recursively", false);
 
defineStaticNoArg(cmdLineRequestProvider::singleDestination);
 
defineStatic(cmdLineRequestProvider::factory, "cmdLine");
 
 
const singleMap& cmdLineRequestProvider::getDstPath(const std::string& source,
        std::string& destination,
        bool baseNameOnly) {
    if (!singleDestination.empty() || noCopy) { // we have the special case that we have one destination file only
        destination = singleDestination;
        static singleMap singleDestMap(source, singleDestination);
        return singleDestMap;
    }
    return requestProvider::getDstPath(source, destination, baseNameOnly);
}
 
void cmdLineRequestProvider::prepareMappings(std::vector<std::string>& sources,
        std::string& destination) {
    std::string dstdir;
    auto dstStat = OutputHandler->getStat(destination);
    if (dstStat == nullptr) { // destination  does not exist, create the new file in the working dir
        if (recursive) {
            dstdir = destination;
        } else {
            singleDestination = destination;
        }
    } else {
        if (dstStat->isDir()) {
            dstdir = destination;
        } else {
            singleDestination = destination;
        }
    }
 
    if (!dstdir.empty()) {
        if (sources.size() == 1) { // special case
            auto srcStat = InputHandler->getStat(sources.front());
            if (srcStat && srcStat->isDir()) {
                pathMap.emplace(sources.front(), dstdir);
                return; // all set, we may return
            }
        }
 
        if (workDir.fIsSet()) {
            pathMap.emplace(workDir, dstdir);
        } else {
            pathMap.emplace("", dstdir);
        }
    }
    if (dstdir.empty() && pathMap.empty() &&
            (sources.size() > 1 || recursive)  && !noCopy) {
        throw std::runtime_error("multiple sources and destination is not a directory");
    }
}
 
void cmdLineRequestProvider::printMappings(std::ostream& stream) {
    if (singleDestination.empty()) {
        stream << "no special singleDestination (used for cmdLineRequestProvider only)\n";
    } else {
        stream << "special destination: '" << singleDestination << "'\n";
    }
    requestProvider::printMappings(stream);
}
void cmdLineRequestProvider::processSource(const std::string& source) {
    auto sourceStat = InputHandler->getStat(source, dereferenceCmdLine);
    if (!sourceStat) {
        if (ignoreMissing) {
            if (! quiet) {
                errMsg::emit(errMsg::level::warning, errMsg::location(),
                             source, "stat", "not found");
            }
            return;
        }
        throw std::runtime_error("can't stat " + source);
    }
    if (sourceStat->isDir()) {
        if (recursive || processCmdLineDirs) {
            std::string dstPath;
            auto mapEntry = getDstPath(source, dstPath, !parents);
            addDirContent(source, dstPath, mapEntry, *sourceStat);
        } else {
            throw std::runtime_error(source + " is a directory");
        }
    } else {
        std::string dst;
        auto mapEntry = getDstPath(source, dst, !parents);
        timerInst(emplace);
        requestSet.emplace(newRequest(InputHandler, source, dst, sourceStat,
                                      mapEntry,
                                      false, copyRequest::clock_type::now()));
    }
}
 
void cmdLineRequestProvider::addDirContent(const std::string& srcpath,
        const std::string& dstpath,
        const singleMap& mapEntry,
        const genericStat& dirStat) {
    // with the subdir list we have only one open dir at a time
    class subdirType {
      public:
        std::string srcPath;
        std::string dstPath;
        std::unique_ptr<const genericStat> dirStat;
        subdirType(const std::string& aSrcPath,
                   const std::string& aDstPath,
                   std::unique_ptr<const genericStat>& aDirStat) :
            srcPath(aSrcPath),
            dstPath(aDstPath),
            dirStat(std::move(aDirStat)) {};
    };
    std::list<subdirType> subdirs;
    {
        auto dir = InputHandler->getDirectory(srcpath);
        while (auto entry = dir->getNextEntry(ignoreMissing)) {
            std::string subpath(srcpath);
            subpath += "/";
            subpath += entry->getName();
            std::string destpath(dstpath);
            destpath += "/";
            destpath += entry->getName();
            auto entryStat = entry->getStat();
            if (entryStat->isDir() &&
                    entryStat->device == dirStat.device &&
                    recursive) {
                subdirs.emplace_back(subpath, destpath, entryStat);
            } else {
                if (entryStat->isRegularFile() || entryStat->isLink() || processCmdLineDirs) {
                    timerInst(emplace);
                    requestSet.emplace(newRequest(InputHandler, subpath, destpath, entryStat,
                                                  mapEntry,
                                                  false, copyRequest::clock_type::now()));
                }
            }
        }
    }
 
    for (auto& subdir : subdirs) {
        addDirContent(subdir.srcPath, subdir.dstPath, mapEntry, *(subdir.dirStat));
        if (processCmdLineDirs) { // special case for listingRequestProvider
            timerInst(emplace);
            requestSet.emplace(newRequest(InputHandler, subdir.srcPath, subdir.dstPath, subdir.dirStat,
                                          mapEntry,
                                          false, copyRequest::clock_type::now()));
        }
    }
}