NidasApp.h

Go to the documentation of this file.

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4; -*-
// vim: set shiftwidth=4 softtabstop=4 expandtab:
/*
 ********************************************************************
    Copyright 2016 UCAR, NCAR, All Rights Reserved
 ********************************************************************
*/
#ifndef NIDAS_CORE_NIDASAPP_H
#define NIDAS_CORE_NIDASAPP_H
 
#include "SampleTag.h"
#include "SampleMatcher.h"
#include "Datasets.h"
#include <nidas/util/UTime.h>
#include <nidas/util/Socket.h>
#include <nidas/util/auto_ptr.h>
 
#include <string>
#include <list>
 
 
 
namespace nidas { namespace core {
 
class Project;
class FileSet;
class SampleOutputBase;
 
class NidasAppException : public nidas::util::Exception
{
public:
    NidasAppException(const std::string& what) :
        Exception(what)
    {}
};
 
 
class NidasApp;
class NidasAppArg;
 
typedef std::vector<NidasAppArg*> nidas_app_arglist_t;
 
typedef std::vector<std::string> ArgVector;
 
inline std::string
expectArg(const ArgVector& args, int i)
{
    if (i < (int)args.size())
    {
        return args[i];
    }
    throw NidasAppException("expected argument for option " + args[i-1]);
}
 
class NidasAppArg
{
public:
    NidasAppArg(const std::string& flags,
                const std::string& syntax = "",
                const std::string& usage = "",
                const std::string& default_ = "",
                bool required = false);
 
    virtual
    ~NidasAppArg();
 
    void
    setRequired(bool isRequired=true);
 
    bool
    isRequired();
 
    void
    acceptShortFlag(bool enable)
    {
        _enableShortFlag = enable;
    }
 
    void
    addFlag(const std::string& flag);
 
    void
    setFlags(const std::string& flags);
 
    operator nidas_app_arglist_t()
    {
        nidas_app_arglist_t args;
        args.push_back(this);
        return args;
    }
 
    std::string
    usage(const std::string& indent = "  ", bool brief = false);
 
    bool
    specified();
 
    const std::string&
    getValue();
 
    const std::string&
    getFlag();
 
    bool
    asBool();
 
    int
    asInt();
 
    float
    asFloat();
 
    virtual bool
    parse(const ArgVector& argv, int* argi = 0);
 
    bool
    accept(const std::string& flag);
 
    void
    setUsageString(const std::string& text)
    {
        _usage = text;
    }
 
    std::string
    getUsageFlags();
 
    void
    setDefault(const std::string& dvalue)
    {
        _default = dvalue;
    }
 
    std::string
    getDefault()
    {
        return _default;
    }
 
protected:
 
    std::string _flags;
    std::string _syntax;
    std::string _usage;
    std::string _default;
    std::string _arg;
    std::string _value;
    bool _enableShortFlag;
    bool _required;
 
    bool
    single();
 
private:
 
    // Prevent the public NidasAppArg members of NidasApp from being
    // replaced with other arguments.
    NidasAppArg&
    operator=(const NidasAppArg&);
    NidasAppArg(const NidasAppArg&);
 
    friend class NidasApp;
};
 
 
class NidasAppInputFilesArg : public NidasAppArg
{
public:
    bool allowFiles;
    bool allowSockets;
 
    void
    setDefaultInput(const std::string& spec, int port=0)
    {
        default_input = spec;
        if (port)
            default_port = port;
        updateUsage();
    }
 
private:
 
    NidasAppInputFilesArg() :
        NidasAppArg("", "input-url [...]"),
        allowFiles(true),
        allowSockets(true),
        default_input(),
        default_port(0)
    {
    }
 
    void
    updateUsage();
 
    std::string default_input;
    int default_port;
 
    virtual
    ~NidasAppInputFilesArg()
    {}
 
    friend class NidasApp;
};
 
 
nidas_app_arglist_t
operator|(nidas_app_arglist_t arglist1, nidas_app_arglist_t arglist2);
 
 
class NidasApp
{
public:
 
    typedef enum {
        NOFORMAT_ID, AUTO_ID, DECIMAL_ID, HEX_ID, OCTAL_ID
    } id_format_t;
 
    class IdFormat
    {
    public:
        IdFormat(id_format_t idfmt=NOFORMAT_ID) :
            _idFormat(idfmt),
            _width(0)
        {
        }
            
        IdFormat(const IdFormat& right) :
            _idFormat(right._idFormat),
            _width(right._width)
        {
        }
 
        IdFormat&
        setDecimalWidth(int width)
        {
            _width = width;
            return *this;
        }
 
        IdFormat&
        operator=(const IdFormat& right)
        {
            if (right._idFormat != NOFORMAT_ID)
                _idFormat = right._idFormat;
            if (right._width != 0)
                _width = right._width;
            return *this;
        }
 
        int
        decimalWidth()
        {
            if (_width)
                return _width;
            return 6;
        }
 
        id_format_t
        idFormat()
        {
            if (_idFormat != NOFORMAT_ID)
                return _idFormat;
            return AUTO_ID;
        }
 
        bool
        unset()
        {
            return (_idFormat == NOFORMAT_ID && _width == 0);
        }
 
        id_format_t _idFormat;
        int _width;
    };
 
    NidasAppArg XmlHeaderFile;
    NidasAppArg LogShow;
    NidasAppArg LogConfig;
    NidasAppArg LogFields;
    NidasAppArg LogParam;
    NidasAppArg Help;
    NidasAppArg ProcessData;
    NidasAppArg StartTime;
    NidasAppArg EndTime;
    NidasAppArg SampleRanges;
    NidasAppArg FormatHexId;
    NidasAppArg FormatSampleId;
    NidasAppArg Version;
    NidasAppInputFilesArg InputFiles;
    NidasAppArg OutputFiles;
    NidasAppArg Username;
    NidasAppArg Hostname;
    NidasAppArg DebugDaemon;
    NidasAppArg ConfigsArg;
    NidasAppArg DatasetName;
    NidasAppArg Clipping;
    NidasAppArg SorterLength;
 
    NidasAppArg PidFile;
 
    nidas_app_arglist_t
    loggingArgs();
 
    NidasApp(const std::string& name);
 
    ~NidasApp();
 
    std::string
    getName()
    {
        return _appname;
    }
 
    void
    setProcessName(const std::string& argv0);
 
    std::string
    getProcessName();
 
    void
    setApplicationInstance();
 
    static NidasApp*
    getApplicationInstance();
 
    void
    allowUnrecognized(bool allow);
 
    bool
    allowUnrecognized();
 
    void
    enableArguments(const nidas_app_arglist_t& arglist);
 
    void
    requireArguments(const nidas_app_arglist_t& arglist);
 
    void
    checkRequiredArguments();
 
    nidas_app_arglist_t
    getArguments();
 
    void
    requireLongFlag(const nidas_app_arglist_t& arglist, bool require=true)
    {
        nidas_app_arglist_t::const_iterator it;
        for (it = arglist.begin(); it != arglist.end(); ++it)
        {
            (*it)->acceptShortFlag(!require);
        }
    }
 
    void
    startArgs(const ArgVector& args);
 
    void
    startArgs(int argc, const char* const argv[]);
 
    NidasAppArg*
    parseNext();
 
    bool
    nextArg(std::string& arg);
 
 
    ArgVector
    unparsedArgs();
 
    ArgVector
    parseArgs(const ArgVector& args);
 
    ArgVector
    parseArgs(int argc, const char* const argv[]);
 
    void
    parseLogConfig(const std::string& optarg);
 
    void
    parseLogLevel(const std::string& optarg)
    {
        parseLogConfig(optarg);
    }
 
    nidas::util::UTime
    parseTime(const std::string& optarg);
 
    void
    parseUsername(const std::string& username);
 
    void
    parseInputs(const std::vector<std::string>& inputs,
                std::string default_input = "",
                int default_port = 0);
 
    bool
    inputsProvided()
    {
        return _dataFileNames.size() > 0  || _sockAddr.get();
    }
 
    void
    parseOutput(const std::string& optarg);
 
    std::string
    outputFileName()
    {
        return _outputFileName;
    }
 
    int
    outputFileLength()
    {
        return _outputFileLength;
    }
 
    int
    logLevel();
 
    void
    resetLogging();
 
    void
    setProcessData(bool process)
    {
        _processData = process;
    }
 
    bool
    processData()
    {
        return _processData;
    }
 
    std::string
    xmlHeaderFile()
    {
        return _xmlFileName;
    }
 
    std::string
    getConfigsXML();
 
    nidas::core::Dataset
    getDataset(const std::string& datasetname);
 
    nidas::util::UTime
    getStartTime()
    {
        return _startTime;
    }
 
    nidas::util::UTime
    getEndTime()
    {
        return _endTime;
    }
 
    void
    setOutputClipping(const nidas::util::UTime& start,
                      const nidas::util::UTime& end,
                      nidas::core::SampleOutputBase* output);
 
    void
    setFileSetTimes(const nidas::util::UTime& start,
                    const nidas::util::UTime& end,
                    nidas::core::FileSet* fset);
 
    bool
    interrupted(bool allow_exception=true);
 
    static void
    setInterrupted(bool interrupted);
 
    void
    setException(const nidas::util::Exception& ex);
 
    bool
    hasException();
 
    nidas::util::Exception
    getException();
 
    Project*
    getProject();
 
    std::string
    usage(const std::string& indent, bool brief);
 
    std::string
    usage(const std::string& indent = "  ");
 
    static void
    setupSignals(void (*callback)(int signum) = 0);
 
    static void
    addSignal(int signum, void (*callback)(int signum) = 0, bool nolog=false);
 
    bool
    helpRequested()
    {
        return _help;
    }
 
    bool
    briefHelp()
    {
        return _brief;
    }
 
    void
    setIdFormat(IdFormat idt);
 
    IdFormat
    getIdFormat()
    {
        return _idFormat;
    }
 
    static
    std::ostream&
    formatSampleId(std::ostream& out, IdFormat idfmt, dsm_sample_id_t sid);
 
    std::ostream&
    formatSampleId(std::ostream& out, dsm_sample_id_t sid);
 
    std::string
    formatId(dsm_sample_id_t sid);
 
    SampleMatcher&
    sampleMatcher()
    {
        return _sampleMatcher;
    }
 
    std::list<std::string>&
    dataFileNames()
    {
        return _dataFileNames;
    }
 
    nidas::util::SocketAddress*
    socketAddress()
    {
        return _sockAddr.get();
    }
 
    std::string
    getHostName();
 
    std::string
    getShortHostName();
 
    std::string
    getUserName()
    { 
        return _username;
    }
 
    uid_t
    getUserID()
    {
        return _userid;
    }
 
    uid_t
    getGroupID()
    {
        return _groupid;
    }
 
    void
    setupProcess();
 
    void
    setupDaemonLogging(bool daemon_mode);
 
    void
    setupDaemonLogging();
 
    void
    setupDaemon(bool daemon_mode);
 
    void
    setupDaemon();
 
    void
    lockMemory();
 
    int
    checkPidFile();
 
    float
    getSorterLength(float min, float max);
 
private:
 
    void
    setupLogScheme();
 
    static NidasApp* application_instance;
 
    std::string _appname;
 
    std::string _argv0;
 
    bool _processData;
 
    std::string _xmlFileName;
 
    IdFormat _idFormat;
 
    SampleMatcher _sampleMatcher;
 
    nidas::util::UTime _startTime;
 
    nidas::util::UTime _endTime;
 
    std::list<std::string> _dataFileNames;
 
    nidas::util::auto_ptr<nidas::util::SocketAddress> _sockAddr;
 
    std::string _outputFileName;
    int _outputFileLength;
 
    bool _help;
    bool _brief;
 
    std::string _username;
 
    std::string _hostname;
 
    uid_t _userid;
 
    gid_t _groupid;
 
    bool _deleteProject;
 
    nidas_app_arglist_t _app_arguments;
 
    ArgVector _argv;
    int _argi;
 
    bool _hasException;
    nidas::util::Exception _exception;
 
    bool _allowUnrecognized;
 
    nidas::util::LogScheme _logscheme;
};
 
 
struct NidasAppArgv
{
    NidasAppArgv(const std::string& argv0,
                 const std::vector<std::string>& args) :
        vargv(), argv(0), argc(0)
    {
        vargv.push_back(strdup(argv0.c_str()));
        for (unsigned int i = 0; i < args.size(); ++i)
        {
            vargv.push_back(strdup(args[i].c_str()));
        }
        argv = &(vargv.front());
        argc = (int)vargv.size();
    }
 
    ArgVector
    unparsedArgs(int optindex)
    {
        return std::vector<std::string>(vargv.begin()+optindex, vargv.end());
    }
 
    ~NidasAppArgv()
    {
        for (int i = 0; i < argc; ++i)
        {
            free(vargv[i]);
        }
    }
 
    std::vector<char*> vargv;
    char** argv;
    int argc;
 
private:
 
    NidasAppArgv(const NidasAppArgv&);
    NidasAppArgv& operator=(const NidasAppArgv&);
 
};
 
 
 
}}  // namespace nidas namespace core
 
#endif  // NIDAS_CORE_NIDASAPP_H