ExecutionTarget.h

Go to the documentation of this file.

// -*- indent-tabs-mode: nil -*-

#ifndef __ARC_EXECUTIONTARGET_H__
#define __ARC_EXECUTIONTARGET_H__

#include <list>
#include <map>
#include <set>
#include <string>

#include <arc/DateTime.h>
#include <arc/compute/Endpoint.h>
#include <arc/URL.h>
#include <arc/Utils.h>
#include <arc/compute/GLUE2Entity.h>
#include <arc/compute/JobDescription.h>
#include <arc/compute/Software.h>
#include <arc/compute/SubmissionStatus.h>

namespace Arc {

  class Job;
  class Logger;
  class SubmitterPlugin;
  class UserConfig;



  class ApplicationEnvironment
    : public Software {
  public:
    ApplicationEnvironment() : FreeSlots(-1), FreeJobs(-1), FreeUserSeats(-1) {}
    ApplicationEnvironment(const std::string& Name)
      : Software(Name), FreeSlots(-1), FreeJobs(-1), FreeUserSeats(-1)  {}
    ApplicationEnvironment(const std::string& Name, const std::string& Version)
      : Software(Name, Version), FreeSlots(-1), FreeJobs(-1), FreeUserSeats(-1)  {}
    ApplicationEnvironment& operator=(const Software& sv) {
      Software::operator=(sv);
      return *this;
    }

    std::string State;
    int FreeSlots;
    int FreeJobs;
    int FreeUserSeats;
  };

  class LocationAttributes {
  public:
    LocationAttributes() : Latitude(0), Longitude(0) {}

    std::string Address;
    std::string Place;
    std::string Country;
    std::string PostCode;
    float Latitude;
    float Longitude;

    friend std::ostream& operator<<(std::ostream& out, const LocationAttributes& l);
  };

  class AdminDomainAttributes {
  public:
    std::string Name;
    std::string Owner;

    friend std::ostream& operator<<(std::ostream& out, const AdminDomainAttributes& ad);
  };

  class ExecutionEnvironmentAttributes {
  public:
    ExecutionEnvironmentAttributes()
      : VirtualMachine(false), CPUClockSpeed(-1), MainMemorySize(-1),
        ConnectivityIn(false), ConnectivityOut(false) {}
    std::string ID;
    std::string Platform;
    bool VirtualMachine;
    std::string CPUVendor;
    std::string CPUModel;
    std::string CPUVersion;
    int CPUClockSpeed;
    int MainMemorySize;


    Software OperatingSystem;

    bool ConnectivityIn;
    bool ConnectivityOut;
    
    friend std::ostream& operator<<(std::ostream&, const ExecutionEnvironmentAttributes&);
  };

  class ComputingManagerAttributes {
  public:
    ComputingManagerAttributes() :
      Reservation(false), BulkSubmission(false),
      TotalPhysicalCPUs(-1), TotalLogicalCPUs(-1), TotalSlots(-1),
      Homogeneous(true),
      WorkingAreaShared(true), WorkingAreaTotal(-1), WorkingAreaFree(-1), WorkingAreaLifeTime(-1),
      CacheTotal(-1), CacheFree(-1) {}

    std::string ID;
    std::string ProductName;
    std::string ProductVersion;
    bool Reservation;
    bool BulkSubmission;
    int TotalPhysicalCPUs;
    int TotalLogicalCPUs;
    int TotalSlots;
    bool Homogeneous;
    std::list<std::string> NetworkInfo;
    bool WorkingAreaShared;
    int WorkingAreaTotal;
    int WorkingAreaFree;
    Period WorkingAreaLifeTime;
    int CacheTotal;
    int CacheFree;

    friend std::ostream& operator<<(std::ostream&, const ComputingManagerAttributes&);
  };

  class ComputingShareAttributes {
  public:
    ComputingShareAttributes() :
      MaxWallTime(-1), MaxTotalWallTime(-1), MinWallTime(-1), DefaultWallTime(-1),
      MaxCPUTime(-1), MaxTotalCPUTime(-1), MinCPUTime(-1), DefaultCPUTime(-1),
      MaxTotalJobs(-1), MaxRunningJobs(-1), MaxWaitingJobs(-1),
      MaxPreLRMSWaitingJobs(-1), MaxUserRunningJobs(-1), MaxSlotsPerJob(-1),
      MaxStageInStreams(-1), MaxStageOutStreams(-1),
      MaxMainMemory(-1), MaxVirtualMemory(-1), MaxDiskSpace(-1),
      Preemption(false),
      TotalJobs(-1), RunningJobs(-1), LocalRunningJobs(-1), WaitingJobs(-1), LocalWaitingJobs(-1),
      SuspendedJobs(-1), LocalSuspendedJobs(-1), StagingJobs(-1), PreLRMSWaitingJobs(-1),
      EstimatedAverageWaitingTime(-1), EstimatedWorstWaitingTime(-1),
      FreeSlots(-1), UsedSlots(-1), RequestedSlots(-1) {}

    std::string ID;

    std::string Name;
    std::string MappingQueue;

    Period MaxWallTime;
    Period MaxTotalWallTime; // not in current Glue2 draft
    Period MinWallTime;
    Period DefaultWallTime;
    Period MaxCPUTime;
    Period MaxTotalCPUTime;
    Period MinCPUTime;
    Period DefaultCPUTime;
    int MaxTotalJobs;
    int MaxRunningJobs;
    int MaxWaitingJobs;
    int MaxPreLRMSWaitingJobs;
    int MaxUserRunningJobs;
    int MaxSlotsPerJob;
    int MaxStageInStreams;
    int MaxStageOutStreams;
    std::string SchedulingPolicy;


    int MaxMainMemory;


    int MaxVirtualMemory;


    int MaxDiskSpace;

    URL DefaultStorageService;
    bool Preemption;
    int TotalJobs;
    int RunningJobs;
    int LocalRunningJobs;
    int WaitingJobs;
    int LocalWaitingJobs;
    int SuspendedJobs;
    int LocalSuspendedJobs;
    int StagingJobs;
    int PreLRMSWaitingJobs;
    Period EstimatedAverageWaitingTime;
    Period EstimatedWorstWaitingTime;
    int FreeSlots;


    std::map<Period, int> FreeSlotsWithDuration;
    int UsedSlots;
    int RequestedSlots;
    std::string ReservationPolicy;

    friend std::ostream& operator<<(std::ostream&, const ComputingShareAttributes&);
  };

  class ComputingEndpointAttributes {
  public:
    ComputingEndpointAttributes() : DowntimeStarts(-1), DowntimeEnds(-1),
      TotalJobs(-1), RunningJobs(-1), WaitingJobs(-1),
      StagingJobs(-1), SuspendedJobs(-1), PreLRMSWaitingJobs(-1) {}

    std::string ID;
    std::string URLString;
    std::string InterfaceName;
    std::string HealthState;
    std::string HealthStateInfo;
    std::string QualityLevel;
    std::set<std::string> Capability;
    std::string Technology;
    std::list<std::string> InterfaceVersion;
    std::list<std::string> InterfaceExtension;
    std::list<std::string> SupportedProfile;
    std::string Implementor;
    Software Implementation;
    std::string ServingState;
    std::string IssuerCA;
    std::list<std::string> TrustedCA;
    Time DowntimeStarts;
    Time DowntimeEnds;
    std::string Staging;
    int TotalJobs;
    int RunningJobs;
    int WaitingJobs;
    int StagingJobs;
    int SuspendedJobs;
    int PreLRMSWaitingJobs;
    // This is singular in the GLUE2 doc: JobDescription
    std::list<std::string> JobDescriptions;
    
    friend std::ostream& operator<<(std::ostream&, const ComputingEndpointAttributes&);
  };

  class ComputingServiceAttributes {
  public:
    ComputingServiceAttributes() :
      TotalJobs(-1), RunningJobs(-1), WaitingJobs(-1),
      StagingJobs(-1), SuspendedJobs(-1), PreLRMSWaitingJobs(-1) {}
    std::string ID;
    std::string Name;
    std::string Type;
    std::set<std::string> Capability;
    std::string QualityLevel;
    int TotalJobs;
    int RunningJobs;
    int WaitingJobs;
    int StagingJobs;
    int SuspendedJobs;
    int PreLRMSWaitingJobs;

    // Other
    Endpoint InformationOriginEndpoint; // this ComputingService was generated while this Endpoint was queried

    friend std::ostream& operator<<(std::ostream& out, const ComputingServiceAttributes& cs);
  };

  class LocationType : public GLUE2Entity<LocationAttributes> {};

  class AdminDomainType : public GLUE2Entity<AdminDomainAttributes> {};

  class ExecutionEnvironmentType : public GLUE2Entity<ExecutionEnvironmentAttributes> {};

  class ComputingManagerType : public GLUE2Entity<ComputingManagerAttributes> {
  public:
    ComputingManagerType() : Benchmarks(new std::map<std::string, double>), ApplicationEnvironments(new std::list<ApplicationEnvironment>) {}
    // TODO: Currently using int as key, use std::string instead for holding ID.
    std::map<int, ExecutionEnvironmentType> ExecutionEnvironment;
    CountedPointer< std::map<std::string, double> > Benchmarks;

    CountedPointer< std::list<ApplicationEnvironment> > ApplicationEnvironments;
  };

  class ComputingShareType : public GLUE2Entity<ComputingShareAttributes> {
  public:
    // TODO: Currently using int, use std::string instead for holding ID.
    std::set<int> ComputingEndpointIDs;
  };

  class ComputingEndpointType : public GLUE2Entity<ComputingEndpointAttributes> {
  public:
    // TODO: Currently using int, use std::string instead for holding ID.
    std::set<int> ComputingShareIDs;
  };

  class ComputingServiceType : public GLUE2Entity<ComputingServiceAttributes> {
  public:
    template<typename T>
    void GetExecutionTargets(T& container) const;

    LocationType Location;
    AdminDomainType AdminDomain;
    // TODO: Currently using int as key, use std::string instead for holding ID.
    std::map<int, ComputingEndpointType> ComputingEndpoint;
    std::map<int, ComputingShareType> ComputingShare;
    std::map<int, ComputingManagerType> ComputingManager;

    friend std::ostream& operator<<(std::ostream&, const ComputingServiceType&);
  private:
    template<typename T>
    void AddExecutionTarget(T& container, const ExecutionTarget& et) const;
    static Logger logger;
  };

  // to avoid "explicit specialization before instantiation" errors
  template <>
  void ComputingServiceType::AddExecutionTarget< std::list<ExecutionTarget> >(std::list<ExecutionTarget>& etList, const ExecutionTarget& et) const;


  class ExecutionTarget {
  public:

    ExecutionTarget() :
      Location(new LocationAttributes()),
      AdminDomain(new AdminDomainAttributes()),
      ComputingService(new ComputingServiceAttributes()),
      ComputingEndpoint(new ComputingEndpointAttributes()),
      ComputingShare(new ComputingShareAttributes()),
      ComputingManager(new ComputingManagerAttributes()),
      ExecutionEnvironment(new ExecutionEnvironmentAttributes()),
      Benchmarks(new std::map<std::string, double>()),
      ApplicationEnvironments(new std::list<ApplicationEnvironment>()) {};


    ExecutionTarget(const ExecutionTarget& t) :
      Location(t.Location), AdminDomain(t.AdminDomain), ComputingService(t.ComputingService),
      ComputingEndpoint(t.ComputingEndpoint), OtherEndpoints(t.OtherEndpoints),
      ComputingShare(t.ComputingShare), ComputingManager(t.ComputingManager),
      ExecutionEnvironment(t.ExecutionEnvironment),
      Benchmarks(t.Benchmarks), ApplicationEnvironments(t.ApplicationEnvironments) {}

    ExecutionTarget(const CountedPointer<LocationAttributes>& l,
                      const CountedPointer<AdminDomainAttributes>& a,
                      const CountedPointer<ComputingServiceAttributes>& cse,
                      const CountedPointer<ComputingEndpointAttributes>& ce,
                      const std::list< CountedPointer<ComputingEndpointAttributes> >& oe,
                      const CountedPointer<ComputingShareAttributes>& csh,
                      const CountedPointer<ComputingManagerAttributes>& cm,
                      const CountedPointer<ExecutionEnvironmentAttributes>& ee,
                      const CountedPointer< std::map<std::string, double> >& b,
                      const CountedPointer< std::list<ApplicationEnvironment> >& ae) :
      Location(l), AdminDomain(a), ComputingService(cse),
      ComputingEndpoint(ce), OtherEndpoints(oe), ComputingShare(csh),
      ComputingManager(cm), ExecutionEnvironment(ee),
      Benchmarks(b), ApplicationEnvironments(ae) {}


    ExecutionTarget(long int addrptr) :
      Location((*(ExecutionTarget*)addrptr).Location),
      AdminDomain((*(ExecutionTarget*)addrptr).AdminDomain),
      ComputingService((*(ExecutionTarget*)addrptr).ComputingService),
      ComputingEndpoint((*(ExecutionTarget*)addrptr).ComputingEndpoint),
      OtherEndpoints((*(ExecutionTarget*)addrptr).OtherEndpoints),
      ComputingShare((*(ExecutionTarget*)addrptr).ComputingShare),
      ComputingManager((*(ExecutionTarget*)addrptr).ComputingManager),
      ExecutionEnvironment((*(ExecutionTarget*)addrptr).ExecutionEnvironment),
      Benchmarks((*(ExecutionTarget*)addrptr).Benchmarks),
      ApplicationEnvironments((*(ExecutionTarget*)addrptr).ApplicationEnvironments) {}


    ExecutionTarget& operator=(const ExecutionTarget& et) {
      Location = et.Location; AdminDomain = et.AdminDomain; ComputingService = et.ComputingService;
      ComputingEndpoint = et.ComputingEndpoint; ComputingEndpoint = et.ComputingEndpoint; ComputingShare = et.ComputingShare;
      ComputingManager = et.ComputingManager; Benchmarks = et.Benchmarks;
      ExecutionEnvironment = et.ExecutionEnvironment; ApplicationEnvironments = et.ApplicationEnvironments;
      return *this;
    }

    ~ExecutionTarget() {};

    SubmissionStatus Submit(const UserConfig& ucfg, const JobDescription& jobdesc, Job& job) const;


    void RegisterJobSubmission(const JobDescription& jobdesc) const;


    friend std::ostream& operator<<(std::ostream& out, const ExecutionTarget& et);

    static void GetExecutionTargets(const std::list<ComputingServiceType>& csList, std::list<ExecutionTarget>& etList);

    CountedPointer<LocationAttributes> Location;
    CountedPointer<AdminDomainAttributes> AdminDomain;
    CountedPointer<ComputingServiceAttributes> ComputingService;
    CountedPointer<ComputingEndpointAttributes> ComputingEndpoint;
    std::list< CountedPointer<ComputingEndpointAttributes> > OtherEndpoints;
    CountedPointer<ComputingShareAttributes> ComputingShare;
    CountedPointer<ComputingManagerAttributes> ComputingManager;
    CountedPointer<ExecutionEnvironmentAttributes> ExecutionEnvironment;
    CountedPointer< std::map<std::string, double> > Benchmarks;
    CountedPointer< std::list<ApplicationEnvironment> > ApplicationEnvironments;

  private:
    static Logger logger;
  };

} // namespace Arc

#endif // __ARC_EXECUTIONTARGET_H__