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 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
    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 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[]) throw (NidasAppException);

    NidasAppArg*
    parseNext() throw (NidasAppException);

    bool
    nextArg(std::string& arg);


    ArgVector
    unparsedArgs();

    ArgVector
    parseArgs(const ArgVector& args) throw (NidasAppException);

    ArgVector
    parseArgs(int argc, const char* const argv[]) throw (NidasAppException);

    void
    parseLogConfig(const std::string& optarg) throw (NidasAppException);

    void
    parseLogLevel(const std::string& optarg) throw (NidasAppException)
    {
        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) throw (NidasAppException);

    bool
    inputsProvided()
    {
        return _dataFileNames.size() > 0  || _sockAddr.get();
    }

    void
    parseOutput(const std::string& optarg) throw (NidasAppException);

    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)
        throw(nidas::util::InvalidParameterException, XMLException);

    nidas::util::UTime
    getStartTime()
    {
        return _startTime;
    }
 
    nidas::util::UTime
    getEndTime()
    {
        return _endTime;
    }

    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 = "  ");

    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;
    }

    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();

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;

    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