JobDescription.h

Go to the documentation of this file.

#ifndef __ARC_JOBDESCRIPTION_H__
#define __ARC_JOBDESCRIPTION_H__

#include <list>
#include <vector>
#include <string>

#include <arc/DateTime.h>
#include <arc/XMLNode.h>
#include <arc/URL.h>
#include <arc/compute/Software.h>


namespace Arc {

  class JobDescriptionParserPluginLoader;
  class ExecutionTarget;

  template<class T>
  class OptIn {
  public:
    OptIn<T>() : optIn(false) {}
    OptIn<T>(const T& t) : v(t), optIn(false) {}
    OptIn<T>(const T& t, bool o) : v(t), optIn(o) {}
    OptIn<T>(const OptIn<T>& ot) : v(ot.v), optIn(ot.optIn) {}

    OptIn<T>& operator=(const OptIn<T>& ot) { v = ot.v; optIn = ot.optIn; return *this; }
    OptIn<T>& operator=(const T& t) { v = t; optIn = false; return *this; }

    operator T() const { return v; }

    T v;
    bool optIn;
  };

  template<class T>
  class Range {
  public:
    Range<T>() : min(0), max(0) {}
    Range<T>(const T& t) : min(t), max(t) {}
    operator T(void) const { return max; }

    Range<T>& operator=(const Range<T>& t) { min = t.min; max = t.max; return *this; };
    Range<T>& operator=(const T& t) { max = t; return *this; };

    T min;
    T max;
  };

  template<class T>
  class ScalableTime {
  public:
    ScalableTime<T>() : benchmark("", -1.) {}
    ScalableTime<T>(const T& t) : range(t) {}

    std::pair<std::string, double> benchmark;
    Range<T> range;
  };

  template<>
  class ScalableTime<int> {
  public:
    ScalableTime<int>() : benchmark("", -1.) {}
    ScalableTime<int>(const int& t) : range(t) {}

    std::pair<std::string, double> benchmark;
    Range<int> range;

    int scaleMin(double s) const { return (int)(range.min*benchmark.second/s); }
    int scaleMax(double s) const { return (int)(range.max*benchmark.second/s); }
  };


  class JobIdentificationType {
  public:
    JobIdentificationType() :
      JobName(""), Description(""), Type("") {}

    std::string JobName;


    std::string Description;


    std::string Type;


    std::list<std::string> Annotation;


    std::list<std::string> ActivityOldID;
  };


  class ExecutableType {
  public:
    ExecutableType() : Path(""), SuccessExitCode(false, 0) {}


    std::string Path;


    std::list<std::string> Argument;


    std::pair<bool, int> SuccessExitCode;
  };


  class RemoteLoggingType {
  public:
    RemoteLoggingType() : optional(false) {}


    std::string ServiceType;


    URL Location;


     bool optional;
  };

  class NotificationType {
  public:
    NotificationType() {}
    std::string Email;
    std::list<std::string> States;
  };

  class ApplicationType {
  public:
    ApplicationType() :
      Rerun(-1),
      ExpirationTime(-1),
      ProcessingStartTime(-1),
      Priority (-1),
      DryRun(false)
      {}
    ApplicationType& operator=(const ApplicationType&);

    ExecutableType Executable;


    std::string Input;


    std::string Output;


    std::string Error;

    std::list< std::pair<std::string, std::string> > Environment;


    std::list<ExecutableType> PreExecutable;


    std::list<ExecutableType> PostExecutable;


    std::string LogDir;


    std::list<RemoteLoggingType> RemoteLogging;

    int Rerun;
    Time ExpirationTime;
    Time ProcessingStartTime;
    int Priority;
    std::list<NotificationType> Notification;
    std::list<URL> CredentialService;
    XMLNode AccessControl;
    bool DryRun;
  };

  class SlotRequirementType {
  public:
    SlotRequirementType() :
      NumberOfSlots(-1),
      SlotsPerHost(-1),
      ExclusiveExecution(EE_DEFAULT) {}
    int NumberOfSlots; // Range?
    int SlotsPerHost; // Range?
    enum ExclusiveExecutionType {
      EE_DEFAULT,
      EE_TRUE,
      EE_FALSE
    } ExclusiveExecution;
  };

  class DiskSpaceRequirementType {
  public:
    DiskSpaceRequirementType() :
      DiskSpace(-1),
      CacheDiskSpace(-1),
      SessionDiskSpace(-1) {}
    Range<int> DiskSpace;
    int CacheDiskSpace;
    int SessionDiskSpace;
  };

  enum SessionDirectoryAccessMode {
    SDAM_NONE = 0,
    SDAM_RO = 1,
    SDAM_RW = 2
  };

  enum NodeAccessType {
    NAT_NONE = 0,
    NAT_INBOUND = 1,
    NAT_OUTBOUND = 2,
    NAT_INOUTBOUND = 3
  };

  class ParallelEnvironmentType {
  public:
    ParallelEnvironmentType() :
      ProcessesPerSlot(-1),
      ThreadsPerProcess(-1) {}
    std::string Type;
    std::string Version;
    int ProcessesPerSlot; // Range?
    int ThreadsPerProcess; // Range?
    std::multimap<std::string, std::string> Options;
  };

  class ResourcesType {
  public:
    ResourcesType() :
      IndividualPhysicalMemory(-1),
      IndividualVirtualMemory(-1),
      SessionLifeTime(-1),
      SessionDirectoryAccess(SDAM_NONE),
      IndividualCPUTime(-1),
      TotalCPUTime(-1),
      IndividualWallTime(-1),
      TotalWallTime(IndividualWallTime),
      NodeAccess(NAT_NONE) {}
    ResourcesType& operator=(const ResourcesType&);

    SoftwareRequirement OperatingSystem;
    std::string Platform;
    std::string NetworkInfo;
    Range<int> IndividualPhysicalMemory;
    Range<int> IndividualVirtualMemory;
    DiskSpaceRequirementType DiskSpaceRequirement;
    Period SessionLifeTime;
    SessionDirectoryAccessMode SessionDirectoryAccess;
    ScalableTime<int> IndividualCPUTime;
    ScalableTime<int> TotalCPUTime;
    ScalableTime<int> IndividualWallTime;
    ScalableTime<int>& TotalWallTime;
    NodeAccessType NodeAccess;
    SoftwareRequirement CEType;
    SlotRequirementType SlotRequirement;
    ParallelEnvironmentType ParallelEnvironment;
    OptIn<std::string> Coprocessor;
    std::string QueueName;
    SoftwareRequirement RunTimeEnvironment;
  };

  class SourceType: public URL {
  public:
    SourceType() {};
    SourceType(const URL& u):URL(u) {};
    SourceType(const std::string& s):URL(s) {};
    SourceType& operator=(const URL& u) { URL::operator=(u); return *this; };
    SourceType& operator=(const std::string& s) { URL::operator=(s); return *this; };
    std::string DelegationID;
  };


  class TargetType: public URL {
  public:

    TargetType() :
      CreationFlag(CFE_DEFAULT),
      UseIfFailure(false),
      UseIfCancel(false),
      UseIfSuccess(true) {};

    TargetType(const URL& u) :
      URL(u),
      CreationFlag(CFE_DEFAULT),
      UseIfFailure(false),
      UseIfCancel(false),
      UseIfSuccess(true) {};

    TargetType(const std::string& s) :
      URL(s),
      CreationFlag(CFE_DEFAULT),
      UseIfFailure(false),
      UseIfCancel(false),
      UseIfSuccess(true) {};
    

    std::string DelegationID;
    
    enum CreationFlagEnumeration {
      CFE_DEFAULT, 
      CFE_OVERWRITE, 
      CFE_APPEND, 
      CFE_DONTOVERWRITE 
    };
    

    CreationFlagEnumeration CreationFlag;
    

    bool UseIfFailure;
    

    bool UseIfCancel;


    bool UseIfSuccess;
  };

  class InputFileType {
  public:
    InputFileType() : Name(""), IsExecutable(false), FileSize(-1) {};
    std::string Name;
    bool IsExecutable;
    long FileSize;

    std::string Checksum;
    std::list<SourceType> Sources;
  };


  class OutputFileType {
  public:
    OutputFileType() : Name("") {};
    std::string Name;
    std::list<TargetType> Targets;
  };


  class DataStagingType {
  public:
    DataStagingType() {};
    
    std::list<InputFileType> InputFiles;
    std::list<OutputFileType> OutputFiles;
  };


  class JobDescriptionResult {
  public:
    JobDescriptionResult(bool r):res(r) { };
    JobDescriptionResult(bool r, const std::string& s):res(r),desc(s) { };
    operator bool(void) { return res; };
    bool operator!(void) { return !res; };
    const std::string& str(void) { return desc; };
  private:
    bool res;
    std::string desc;
  };

  class JobDescription {
  public:
    friend class JobDescriptionParserPlugin;
    JobDescription() : alternatives(), current(alternatives.begin()) {};

    JobDescription(const JobDescription& j, bool withAlternatives = true);

    // Language wrapper constructor
    JobDescription(const long int& ptraddr);

    ~JobDescription() {}

    JobDescription& operator=(const JobDescription& j);

    void AddAlternative(const JobDescription& j);

    bool HasAlternatives() const { return !alternatives.empty(); }
    const std::list<JobDescription>& GetAlternatives() const { return alternatives; }
    std::list<JobDescription>& GetAlternatives() { return alternatives; }
    std::list<JobDescription>  GetAlternativesCopy() const { return alternatives; }
    bool UseAlternative();
    void UseOriginal();

    void RemoveAlternatives();


    static JobDescriptionResult Parse(const std::string& source, std::list<JobDescription>& jobdescs, const std::string& language = "", const std::string& dialect = "");

    static JobDescriptionResult ParseFromFile(const std::string& filename, std::list<JobDescription>& jobdescs, const std::string& language = "", const std::string& dialect = "");


    JobDescriptionResult UnParse(std::string& product, std::string language, const std::string& dialect = "") const;


    const std::string& GetSourceLanguage() const { return sourceLanguage; }


    JobDescriptionResult SaveToStream(std::ostream& out, const std::string& format) const;


    bool Prepare(const ExecutionTarget& et) { return Prepare(&et); }

    bool Prepare() { return Prepare(NULL); }

    static bool GetTestJob(int testid, JobDescription& jobdescription);


    JobIdentificationType Identification;
    

    ApplicationType Application;
    

    ResourcesType Resources;
    

    DataStagingType DataStaging;


    std::map<std::string, std::string> OtherAttributes;

  private:
    bool Prepare(const ExecutionTarget* et);
  
    void Set(const JobDescription& j);

    std::string sourceLanguage;

    std::list<JobDescription> alternatives;
    std::list<JobDescription>::iterator current;

    static Glib::Mutex jdpl_lock;
    static JobDescriptionParserPluginLoader *jdpl;

    static Logger logger;
  };

} // namespace Arc

#endif // __ARC_JOBDESCRIPTION_H__