src/ydfx_gui/SalomeResourceModel.cxx

   1 #include "SalomeResourceModel.hxx"
   2 #include "RuntimeSALOME.hxx"
   3 #include "SALOME_ResourcesManager.hxx"
   4 #include "SALOME_LifeCycleCORBA.hxx"
   5 #include <ctime>
   6
   7 SalomeResourceModel::SalomeResourceModel()
   8 : AbstractResourceModel(),
   9   _wantedMachine("localhost"),
  10   _nbProcs(1),
  11   _hours(0),
  12   _minutes(0),
  13   _wcKey(""),
  14   _localDirectory("/tmp"),
  15   _remoteDirectory("/tmp"),
  16   _parallelizeStatus(true),
  17   _in_files()
  18 {
  19 }
  20
  21 SalomeResourceModel::~SalomeResourceModel()
  22 {
  23 }
  24
  25 bool SalomeResourceModel::isMachineInteractive(const std::string& machine)const
  26 {
  27   return !machine.compare("localhost");
  28 }
  29
  30 std::vector< std::string > SalomeResourceModel::getFittingMachines()const
  31 {
  32   std::vector< std::string > resultat;
  33   YACS::ENGINE::RuntimeSALOME* runTime = YACS::ENGINE::getSALOMERuntime();
  34   CORBA::ORB_ptr orb = runTime->getOrb();
  35   if (!orb) return resultat;
  36
  37   SALOME_NamingService namingService(orb);
  38   SALOME_LifeCycleCORBA lcc(&namingService);
  39
  40   CORBA::Object_var obj;
  41   obj=namingService.Resolve(SALOME_ResourcesManager::_ResourcesManagerNameInNS);
  42   if (CORBA::is_nil(obj)) return resultat;
  43
  44   Engines::ResourcesManager_var resManager;
  45   resManager = Engines::ResourcesManager::_narrow(obj);
  46   if(!resManager) return resultat;
  47
  48   Engines::ResourceParameters params;
  49   lcc.preSet(params);
  50
  51   Engines::ResourceList* resourceList = resManager->GetFittingResources(params);
  52
  53   for (int i = 0; i < resourceList->length(); i++)
  54   {
  55     const char* aResource = (*resourceList)[i];
  56     resultat.push_back(aResource);
  57   }
  58   return resultat;
  59 }
  60
  61 void SalomeResourceModel::setWantedMachine(const std::string& v)
  62 {
  63   _wantedMachine = v;
  64 }
  65
  66 std::string SalomeResourceModel::getWantedMachine()const
  67 {
  68   return _wantedMachine;
  69 }
  70
  71 void SalomeResourceModel::setNbprocs(unsigned int v)
  72 {
  73   _nbProcs = v;
  74 }
  75
  76 unsigned int SalomeResourceModel::getNbprocs()const
  77 {
  78   return _nbProcs;
  79 }
  80
  81 void SalomeResourceModel::setMaxDurationHours(int v)
  82 {
  83   _hours = v;
  84 }
  85
  86 int SalomeResourceModel::getMaxDurationHours()const
  87 {
  88   return _hours;
  89 }
  90
  91 void SalomeResourceModel::setMaxDurationMinutes(int v)
  92 {
  93   _minutes = v;
  94 }
  95
  96 int SalomeResourceModel::getMaxDurationMinutes()const
  97 {
  98   return _minutes;
  99 }
 100
 101 void SalomeResourceModel::setWckey(const std::string& v)
 102 {
 103   _wcKey = v;
 104 }
 105
 106 std::string SalomeResourceModel::getWckey()const
 107 {
 108   return _wcKey;
 109 }
 110
 111 void SalomeResourceModel::setLocalDir(const std::string& v)
 112 {
 113   _localDirectory = v;
 114 }
 115
 116 std::string SalomeResourceModel::getLocalDir()const
 117 {
 118   return _localDirectory;
 119 }
 120
 121 void SalomeResourceModel::setRemoteDir(const std::string& v)
 122 {
 123   _remoteDirectory = v;
 124 }
 125
 126 std::string SalomeResourceModel::getRemoteDir()const
 127 {
 128   return _remoteDirectory;
 129 }
 130
 131 std::string SalomeResourceModel::getDefaultRemoteDir(std::string machine)const
 132 {
 133   std::string result = "";
 134   YACS::ENGINE::RuntimeSALOME* runTime = YACS::ENGINE::getSALOMERuntime();
 135   CORBA::ORB_ptr orb = runTime->getOrb();
 136   if (!orb) return result;
 137
 138   SALOME_NamingService namingService(orb);
 139   SALOME_LifeCycleCORBA lcc(&namingService);
 140
 141   CORBA::Object_var obj;
 142   obj=namingService.Resolve(SALOME_ResourcesManager::_ResourcesManagerNameInNS);
 143   if (CORBA::is_nil(obj)) return result;
 144
 145   Engines::ResourcesManager_var resManager;
 146   resManager = Engines::ResourcesManager::_narrow(obj);
 147   if(!resManager) return result;
 148
 149   Engines::ResourceParameters params;
 150   lcc.preSet(params);
 151
 152   try
 153   {
 154     Engines::ResourceDefinition * rd;
 155     rd = resManager->GetResourceDefinition(machine.c_str());
 156     result = rd->working_directory.in();
 157     if (result != "")
 158     {
 159       time_t rawtime;
 160       time(&rawtime);
 161       std::string launch_date = ctime(&rawtime);
 162       for (int i = 0; i < launch_date.size(); i++)
 163         if (launch_date[i] == '/' ||
 164             launch_date[i] == '-' ||
 165             launch_date[i] == ':' ||
 166             launch_date[i] == ' ')
 167           launch_date[i] = '_';
 168       launch_date.erase(--launch_date.end()); // Last caracter is a \n
 169       result += "/run_";
 170       result += launch_date;
 171     }
 172   }
 173   catch (...)
 174   {
 175   }
 176
 177   return result;
 178 }
 179
 180 void SalomeResourceModel::setParallelizeStatus(bool v)
 181 {
 182   _parallelizeStatus = v;
 183 }
 184
 185 bool SalomeResourceModel::getParallelizeStatus()const
 186 {
 187   return _parallelizeStatus;
 188 }
 189
 190 const std::list<std::string>& SalomeResourceModel::getInFiles()const
 191 {
 192   return _in_files;
 193 }
 194
 195 std::list<std::string>& SalomeResourceModel::getInFiles()
 196 {
 197   return _in_files;
 198 }