oscommand.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Bert
 Date:          Nov 2013
________________________________________________________________________
 
-*/
 
#include "basicmod.h"
 
#include "bufstringset.h"
#include "od_iosfwd.h"
#include "uistring.h"
 
mFDQtclass(QProcess);
class qstreambuf;
class StreamProvider;
 
namespace OS
{
 
enum LaunchType { Wait4Finish, RunInBG, Batch, BatchWait };
enum KeyStyle   { NewStyle, OldStyle };
 
mDeprecatedObs inline bool isBatchProg( OS::LaunchType lt );
inline bool isOldStyle( OS::KeyStyle ks ) { return ks == OS::OldStyle; }
 
mExpClass(Basic) CommandExecPars
{
public:
                        CommandExecPars( LaunchType lt=Wait4Finish )
                            : launchtype_(lt)
                            , createstreams_(false)
                            , needmonitor_(false)
                            , prioritylevel_(lt>=Batch ? -1.0f : 0.0f)
                            , isconsoleuiprog_(false)
                            , runasadmin_(false)     {}
 
    mDeprecated         ("Use CommandExecPars(LaunchType) instead")
    explicit            CommandExecPars(bool isbatchprog);
 
    mDefSetupClssMemb(CommandExecPars,LaunchType,launchtype);
    mDefSetupClssMemb(CommandExecPars,bool,createstreams);
    mDefSetupClssMemb(CommandExecPars,bool,needmonitor);
    mDefSetupClssMemb(CommandExecPars,BufferString,monitorfnm);
 
    mDefSetupClssMemb(CommandExecPars,float,prioritylevel);
 
    mDefSetupClssMemb(CommandExecPars,bool,isconsoleuiprog);
 
    mDefSetupClssMemb(CommandExecPars,bool,runasadmin);
 
    mDefSetupClssMemb(CommandExecPars,BufferString,workingdir);
 
    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);
};
 
 
 
class CommandLauncher;
 
mExpClass(Basic) MachineCommand
{
public:
 
                        MachineCommand( const char* prognm=nullptr )
                            : prognm_(prognm)           {}
                        MachineCommand( const char* prognm,
                                        const BufferStringSet& arguments )
                            : prognm_(prognm)
                            , args_(arguments)          {}
                        MachineCommand(const char* prognm,const char* arg1,
                                       const char* arg2=0,const char* arg3=0,
                                       const char* arg4=0,const char* arg5=0);
                        MachineCommand(const char* prognm,bool isolated);
                        MachineCommand(const MachineCommand&,bool isolated);
 
    const char*         program() const                 { return prognm_; }
    const BufferStringSet& args() const                 { return args_; }
    BufferString        toString(const CommandExecPars* =nullptr) const;
 
    MachineCommand&     setProgram( const char* pn )
                        { prognm_.set( pn ); return *this; }
    MachineCommand&     addArg(const char*);
    MachineCommand&     addArgs(const BufferStringSet&);
    MachineCommand&     addFlag( const char* flg, KeyStyle ks=NewStyle )
                        { return addKeyedArg(flg,nullptr,ks); }
    MachineCommand&     addKeyedArg(const char* ky,const char* valstr,
                                    KeyStyle ks=NewStyle);
    MachineCommand&     addPipe()       { return addArg("|"); }
    MachineCommand&     addFileRedirect(const char* fnm,int stdcode=0,
                                        bool append=false);
                        // convenience:
    template <class T>
    MachineCommand&     addArg( const T& t )    { return addArg(::toString(t));}
    template <class T>
    MachineCommand&     addKeyedArg( const char* ky, const T& t,
                                     KeyStyle ks=NewStyle )
                        { return addKeyedArg(ky,::toString(t),ks);}
 
    mDeprecatedDef const char*  command() const;
    mDeprecatedDef void setCommand(const char*);
    mDeprecatedDef const char*  getSingleStringRep() const;
    mDeprecatedDef bool setFromSingleStringRep(const char*,
                                                bool ignorehostname=false);
    bool                hostIsWindows() const           { return hostiswin_; }
    void                setHostIsWindows( bool yn )     { hostiswin_ = yn; }
    const char*         hostName() const                { return hname_; }
    void                setHostName( const char* hnm )  { hname_ = hnm; }
    const char*         remExec() const                 { return remexec_; }
    void                setRemExec( const char* sh )    { remexec_ = sh; }
 
    bool                isBad() const           { return prognm_.isEmpty(); }
    bool                hasHostName() const     { return !hname_.isEmpty(); }
 
    static const char*  defaultRemExec()        { return defremexec_; }
    static void         setDefaultRemExec( const char* s ) { defremexec_ = s; }
 
    static const char*  odRemExecCmd()          { return "od_remexec"; }
    static const char*  sKeyRemoteHost()        { return "machine"; }
    static const char*  sKeyRemoteCmd()         { return "cmd"; }
    static const char*  sKeyPrimaryHost()       { return "primaryhost"; }
    static const char*  sKeyPrimaryPort()       { return "primaryport"; }
    static const char*  sKeyJobID()             { return "jobid"; }
 
    bool                execute(LaunchType lt=Wait4Finish,
                                const char* workdir=nullptr);
    bool                execute(BufferString& output_stdout,
                                BufferString* output_stderr=nullptr,
                                const char* workdir=nullptr);
    bool                execute(const CommandExecPars&);
 
    BufferString        runAndCollectOutput(BufferString* errmsg=nullptr);
 
private:
 
    void                setIsolated(const char* prognm);
    MachineCommand      getExecCommand(const CommandExecPars* =nullptr) const;
    void                addShellIfNeeded();
    BufferString        prognm_;
    BufferStringSet     args_;
    bool                hostiswin_              = __iswin__;
    BufferString        hname_;
    BufferString        remexec_                = defremexec_;
    bool                needshell_ = false;
 
    static BufferString defremexec_;
 
    friend class CommandLauncher;
    friend class ::StreamProvider;
 
public:
 
    mDeprecatedDef BufferString getSingleStringRep(bool noremote=false) const;
    mDeprecated("Use sKeyPrimaryHost()")
    static const char*  sKeyMasterHost()        { return "primaryhost"; }
    mDeprecated("Use sKeyPrimaryPort()")
    static const char*  sKeyMasterPort()        { return "primaryport"; }
 
    //Only for expert usage
    static void         setIsolationScript(const char*);
 
};
 
 
mExpClass(Basic) CommandLauncher
{ mODTextTranslationClass(CommandLauncher);
public:
                        CommandLauncher(const MachineCommand&);
                        ~CommandLauncher();
 
    void                set(const MachineCommand&);
 
    bool                execute(LaunchType lt=Wait4Finish,
                                const char* workdir=nullptr);
    bool                execute(BufferString& output_stdout,
                                BufferString* output_stderr=nullptr,
                                const char* workdir=nullptr);
    bool                execute(const CommandExecPars&);
    bool                startServer(bool inpythonenv=false,
                                    double maxwaittm=20 /* seconds */);
 
    PID_Type            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_; }
 
    mDeprecated("Provide cmd and arguments")
    static bool         openTerminal(const char* workdir);
    static bool         openTerminal(const char* cmd,
                                     const BufferStringSet* args,
                                     BufferString* errmsg =nullptr,
                                     uiString* launchermsg =nullptr,
                                     const char* workdir =nullptr);
 
protected:
 
    void                reset();
    bool                doExecute(const MachineCommand&,const CommandExecPars&);
    int                 catchError();
    bool                startDetached(const MachineCommand&,
                                      bool inconsole=false,
                                      const char* workingdir=nullptr);
    void                startMonitor();
 
    MachineCommand      machcmd_;
    BufferString        monitorfnm_;
    bool                redirectoutput_;
 
    BufferString        progvwrcmd_;
    uiString            errmsg_;
    const BufferString  odprogressviewer_;
 
    QProcess*           process_;
    PID_Type            pid_;
 
    od_istream*         stdoutput_;
    od_istream*         stderror_;
    od_ostream*         stdinput_;
 
    qstreambuf*         stdoutputbuf_;
    qstreambuf*         stderrorbuf_;
    qstreambuf*         stdinputbuf_;
 
private:
    void                setIsolated();
    void                adaptForV7(const OS::MachineCommand&);
 
public:
    mDeprecatedDef static void addShellIfNeeded(BufferString& cmd);
    mDeprecatedDef static void addQuotesIfNeeded(BufferString& cmd);
    static void         manageQProcess(QProcess*);
};
 
 
mDeprecatedDef mGlobal(Basic) bool ExecCommand(const char* cmd,
                                LaunchType lt=Wait4Finish,
                                BufferString* stdoutput=0,
                                BufferString* stderror=0);
 
 
} // namespace OS
 
mDeprecatedDef mGlobal(Basic) bool ExecODProgram(const char* prognm,
                                  const char* args=0,
                                  OS::LaunchType lt=OS::RunInBG);
 
 
namespace OD
{
 
mGlobal(Basic) void DisplayErrorMessage(const char*);
 
} // namespace OD