oscommand.h

Go to the documentation of this file.

#ifndef oscommand_h
#define oscommand_h

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Bert
 Date:          Nov 2013
 RCS:           $Id$
________________________________________________________________________

-*/

#include "basicmod.h"
#include "bufstring.h"
#include "uistring.h"

mFDQtclass(QProcess);
class od_istream;
class od_ostream;
class qstreambuf;

namespace OS
{


enum LaunchType { Wait4Finish, RunInBG };


mExpClass(Basic) CommandExecPars
{
public:
                        CommandExecPars( bool isbatchprog=false )
                            : needmonitor_(false)
                            , createstreams_(false)
                            , prioritylevel_(isbatchprog ? -1.0f : 0.0f)
                            , launchtype_(isbatchprog ? RunInBG : Wait4Finish)
                            , isconsoleuiprog_(false)   {}

    mDefSetupClssMemb(CommandExecPars,bool,createstreams);
    mDefSetupClssMemb(CommandExecPars,bool,needmonitor);
    mDefSetupClssMemb(CommandExecPars,BufferString,monitorfnm);

    mDefSetupClssMemb(CommandExecPars,LaunchType,launchtype);

    mDefSetupClssMemb(CommandExecPars,float,prioritylevel);

    mDefSetupClssMemb(CommandExecPars,bool,isconsoleuiprog);

    void                usePar(const IOPar&);
    void                fillPar(IOPar&) const;
    void                removeFromPar(IOPar&) const;

    static const char*  sKeyPriority()  { return "priority"; }

    static const StepInterval<int>      cMachineUserPriorityRange(bool iswin);
    static int          getMachinePriority(float priolevel,bool iswin);
};


mExpClass(Basic) MachineCommand
{
public:

                        MachineCommand(const char* comm=0);
                        MachineCommand(const char* comm,const char* hnm);

    inline const char*  command() const                 { return comm_; }
    inline void         setCommand( const char* cm )    { comm_ = cm; }
    inline const char*  hostName() const                { return hname_; }
    inline void         setHostName( const char* hnm )  { hname_ = hnm; }
    inline const char*  remExec() const                 { return remexec_; }
    inline void         setRemExec( const char* sh )    { remexec_ = sh; }

    inline bool         isBad() const           { return comm_.isEmpty(); }

    bool                setFromSingleStringRep(const char*,
                                                bool ignorehostname=false);
    const char*         getSingleStringRep() const;

    bool                hasHostName() const     { return !hname_.isEmpty(); }

    static const char*  defaultRemExec()        { return defremexec_; }
    static void         setDefaultRemExec( const char* s ) { defremexec_ = s; }

    static const char*  extractHostName(const char*,BufferString&);
    BufferString        getLocalCommand() const;

    BufferString        runAndCollectOutput(BufferString* errmsg=nullptr);

    static const char*  odRemExecCmd()          { return "od_remexec"; }
    static const char*  sKeyRemoteHost()        { return "machine"; }
    static const char*  sKeyRemoteCmd()         { return "cmd"; }
    static const char*  sKeyMasterHost()        { return "masterhost"; }
    static const char*  sKeyMasterPort()        { return "masterport"; }
    static const char*  sKeyBG()                { return "bg"; }
    static const char*  sKeyFG()                { return "fg"; }
    static const char*  sKeyJobID()             { return "jobid"; }

protected:

    BufferString        comm_;
    BufferString        hname_;
    BufferString        remexec_;

    static BufferString defremexec_;

};


mExpClass(Basic) CommandLauncher
{ mODTextTranslationClass(CommandLauncher);
public:
                        CommandLauncher(const MachineCommand&);
                        CommandLauncher(const MachineCommand&,bool isolated);
                        ~CommandLauncher();

    void                set(const MachineCommand&);
    void                set(const MachineCommand&,bool isolated);

    bool                execute(BufferString& output_stdout,
                                BufferString* output_stderr=0);
    bool                execute(const CommandExecPars& pars=CommandExecPars());

    int                 processID() const;
    const char*         monitorFileName() const { return monitorfnm_; }
    uiString            errorMsg() const        { return errmsg_; }

    od_istream*         getStdOutput() { return stdoutput_; }
    od_istream*         getStdError() { return stderror_; }
    od_ostream*         getStdInput() { return stdinput_; }

protected:

    void                reset();
    bool                doExecute(const char* comm,bool wait4finish,
                                  bool inconsole = false,
                                  bool createstreams=false );
    int                 catchError();
    bool                startDetached(const char*,bool inconsole=false);

    MachineCommand      machcmd_;
    BufferString        monitorfnm_;
    bool                redirectoutput_;

    BufferString        progvwrcmd_;
    uiString            errmsg_;
    const BufferString  odprogressviewer_;

    QProcess*           process_;
    od_int64            pid_;

    od_istream*         stdoutput_;
    od_istream*         stderror_;
    od_ostream*         stdinput_;

    qstreambuf*         stdoutputbuf_;
    qstreambuf*         stderrorbuf_;
    qstreambuf*         stdinputbuf_;

private:
    void                setIsolated();

public: //Extra utilities, not for general use
    static void         addShellIfNeeded(BufferString& cmd);
    static void         addQuotesIfNeeded(BufferString& cmd);
    static void         manageQProcess(QProcess*);
};


mGlobal(Basic) bool ExecCommand(const char* cmd,LaunchType lt=Wait4Finish,
                                BufferString* stdoutput=0,
                                BufferString* stderror=0);


} // namespace OS

mGlobal(Basic) bool ExecODProgram(const char* prognm,const char* args=0,
                                  OS::LaunchType lt=OS::RunInBG);


#endif