jobrunner.h

Go to the documentation of this file.

#ifndef jobrunner_h
#define jobrunner_h

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H.Bril
 Date:          Oct 2004
 RCS:           $Id$
________________________________________________________________________

-*/

#include "mmprocmod.h"
#include "executor.h"
#include "jobinfo.h"

class BufferStringSet;
class FilePath;
class HostData;
class JobDescProv;
class JobIOMgr;
class StatusInfo;

mExpClass(MMProc) HostNFailInfo
{ mODTextTranslationClass(HostNFailInfo);
public:
                        HostNFailInfo( const HostData& hd )
                            : hostdata_(hd)
                            , nrfailures_(0)
                            , nrsucces_(0)
                            , lastsuccess_(0)
                            , starttime_(0)
                            , inuse_(false) {}

    const HostData&     hostdata_;
    int                 nrfailures_; 
    int                 nrsucces_;
    int                 starttime_;  
    int                 lastsuccess_; 
    bool                inuse_;
};


mExpClass(MMProc) JobRunner : public Executor
{ mODTextTranslationClass(JobRunner);
public:

                                JobRunner(JobDescProv*,const char* cmd);
                                ~JobRunner();

    const JobDescProv*          descProv() const        { return descprov_; }

    const ObjectSet<HostNFailInfo>& hostInfo() const    { return hostinfo_; }
    bool                        addHost(const HostData&);
    void                        removeHost(int);
    void                        pauseHost(int,bool);
    bool                        stopAll();
    bool                        hostFailed(int) const;
    bool                        isPaused(int) const;
    bool                        isAssigned( const JobInfo& ji ) const;

    int                         nrJobs( bool failed=false ) const
                                { return (failed ? failedjobs_ : jobinfos_)
                                         .size(); }
    const JobInfo&              jobInfo( int idx, bool failed=false ) const
                                { return *(failed ? failedjobs_ : jobinfos_)
                                         [idx]; }

    int                         jobsDone() const;
    int                         jobsInProgress() const;
    int                         jobsLeft() const
                                { return jobinfos_.size() - jobsDone(); }
    int                         totalJobs() const
                                { return jobinfos_.size()+failedjobs_.size(); }
    JobInfo*                    currentJob(const HostNFailInfo*) const;

    int                         nextStep()      { return doCycle(); }
    od_int64                    nrDone() const  { return jobsDone(); }
    od_int64                    totalNr() const { return totalJobs(); }
    uiString                    uiMessage() const;
    uiString                    nrDoneMessage() const;

                                // Set these before first step
    void                        setFirstPort( int n )       { firstport_ = n; }
    void                        setRshComm( const char* s ) { rshcomm_ = s; }
    void                        setProg( const char* s )    { prog_ = s; }
                                // Set this anytime
    void                        setNiceNess( int n );

    void                        showMachStatus( BufferStringSet& ) const;
    const FilePath&             getBaseFilePath(JobInfo&, const HostData&);

    Notifier<JobRunner>         preJobStart;
    Notifier<JobRunner>         postJobStart;
    Notifier<JobRunner>         jobFailed;
    Notifier<JobRunner>         msgAvail;

    const JobInfo&              curJobInfo() const      { return *curjobinfo_; }
    IOPar&                      curJobIOPar()           { return curjobiop_; }
    const FilePath&             curJobFilePath()        { return curjobfp_; }
    int                         getLastReceivedTime(JobInfo&);

    const char*                 procDir() const { return procdir_.buf(); }
                                // processing directory on local machine
    uiString                    errorMsg() const;

protected:

    JobDescProv*                descprov_;
    ObjectSet<JobInfo>          jobinfos_;
    ObjectSet<HostNFailInfo>    hostinfo_;
    ObjectSet<JobInfo>          failedjobs_;
    BufferString                prog_;
    BufferString                procdir_;
    FilePath&                   curjobfp_;
    IOPar&                      curjobiop_;
    JobInfo*                    curjobinfo_;

    JobIOMgr&                   iomgr();
    JobIOMgr*                   iomgr_;

    int                         niceval_;
    int                         firstport_;
    BufferString                rshcomm_;
    int                         maxhostfailures_; 
    int                         maxjobfailures_;  
    int                         maxjobhstfails_;  
    int                         starttimeout_;
    int                         failtimeout_;
    int                         wrapuptimeout_;
    int                         hosttimeout_;
    int                         startwaittime_;  
    uiString                    errmsg_;

    int                         doCycle();
    HostNFailInfo*              hostNFailInfoFor(const HostData*) const;

    void                        updateJobInfo();
    void                        handleStatusInfo( StatusInfo& );
    JobInfo*                    gtJob( int descnr );

    void                        failedJob( JobInfo&, JobInfo::State );

    enum StartRes               { Started, NotStarted, JobBad, HostBad };
    StartRes                    startJob( JobInfo& ji, HostNFailInfo& jhi );
    bool                        runJob(JobInfo&,const HostData&);


    enum AssignStat             { NotReady, BadHost, JobStarted, NoJobs };
    AssignStat                  assignJob(HostNFailInfo&);
    bool                        haveIncomplete() const;

    enum HostStat               { OK = 0, SomeFailed = 1, HostFailed = 2 };
    HostStat                    hostStatus(const HostNFailInfo*) const;
    void                        handleExitStatus(JobInfo&);
};

#endif