src/ResourcesManager/SALOME_ResourcesCatalog_Handler.cxx

   1 //  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  SALOME ResourcesCatalog : implementation of catalog resources parsing (SALOME_ModuleCatalog.idl)
  24 //  File   : SALOME_ResourcesCatalog_Handler.cxx
  25 //  Author : Estelle Deville
  26 //  Module : SALOME
  27 //$Header$
  28 //
  29 #include "SALOME_ResourcesCatalog_Handler.hxx"
  30 #include "Basics_Utils.hxx"
  31 #include <iostream>
  32 #include <sstream>
  33 #include <map>
  34
  35 //=============================================================================
  36 /*!
  37  *  Constructor
  38  *  \param listOfResources: map of ParserResourcesType to fill when parsing
  39  */
  40 //=============================================================================
  41
  42 SALOME_ResourcesCatalog_Handler::
  43 SALOME_ResourcesCatalog_Handler(MapOfParserResourcesType& resources_list): _resources_list(resources_list)
  44 {
  45   //XML tags initialisation
  46   test_machine = "machine";
  47   test_cluster = "cluster";
  48   test_name = "name";
  49   test_hostname = "hostname";
  50   test_protocol = "protocol";
  51   test_cluster_internal_protocol = "iprotocol";
  52   test_mode = "mode";
  53   test_batch = "batch";
  54   test_mpi = "mpi";
  55   test_user_name = "userName";
  56   test_appli_path = "appliPath";
  57   test_modules = "modules";
  58   test_module_name = "moduleName";
  59   test_components = "component";
  60   test_component_name = "name";
  61   test_os = "OS";
  62   test_mem_in_mb = "memInMB";
  63   test_cpu_freq_mhz = "CPUFreqMHz";
  64   test_nb_of_nodes = "nbOfNodes";
  65   test_nb_of_proc = "nbOfProc";
  66   test_nb_of_proc_per_node = "nbOfProcPerNode";
  67   test_batch_queue = "batchQueue";
  68   test_user_commands = "userCommands";
  69   test_use = "use";
  70   test_members = "members";
  71 }
  72
  73 //=============================================================================
  74 /*!
  75  *  Destructor
  76  */
  77 //=============================================================================
  78
  79 SALOME_ResourcesCatalog_Handler::~SALOME_ResourcesCatalog_Handler()
  80 {
  81   //  cout << "SALOME_ResourcesCatalog_Handler destruction") << endl;
  82 }
  83
  84 //=============================================================================
  85 /*!
  86  *  Retrieves DS after the file parse.
  87  */
  88 //=============================================================================
  89
  90 const MapOfParserResourcesType&
  91 SALOME_ResourcesCatalog_Handler::GetResourcesAfterParsing() const
  92 {
  93   return _resources_list;
  94 }
  95
  96 //=============================================================================
  97 /*!
  98  *  Processes XML document and fills the list of resources
  99  */
 100 //=============================================================================
 101
 102 void SALOME_ResourcesCatalog_Handler::ProcessXmlDocument(xmlDocPtr theDoc)
 103 {
 104   // Empty private elements
 105   _resources_list.clear();
 106
 107   //default resources
 108   _resource.Clear();
 109         _resource.HostName = Kernel_Utils::GetHostname();
 110         _resource.Name = Kernel_Utils::GetHostname();
 111         _resource.DataForSort._Name = Kernel_Utils::GetHostname();
 112         _resources_list[Kernel_Utils::GetHostname()] = _resource;
 113
 114   // Get the document root node
 115   xmlNodePtr aCurNode = xmlDocGetRootElement(theDoc);
 116
 117   aCurNode = aCurNode->xmlChildrenNode;
 118
 119   // Processing the document nodes
 120   while(aCurNode != NULL)
 121   {
 122     // Cas d'une machine ou d'une machine batch
 123     if (!xmlStrcmp(aCurNode->name,(const xmlChar*)test_machine))
 124     {
 125       _resource.Clear();
 126       bool Ok = ProcessMachine(aCurNode, _resource);
 127       if (Ok)
 128       {
 129         // Adding a resource
 130         if(_resource.HostName == "localhost")
 131         {
 132           _resource.HostName = Kernel_Utils::GetHostname();
 133           if (_resource.Name == "localhost")
 134           {
 135             _resource.Name = Kernel_Utils::GetHostname();
 136             _resource.DataForSort._Name = Kernel_Utils::GetHostname();
 137           }
 138         }
 139         std::map<std::string, ParserResourcesType>::const_iterator iter = _resources_list.find(_resource.Name);
 140         if (iter != _resources_list.end())
 141           RES_INFOS("Warning resource " << _resource.Name << " already added, keep last resource found !");
 142         _resources_list[_resource.Name] = _resource;
 143       }
 144     }
 145     // Cas de la déclaration d'un cluster
 146     if (!xmlStrcmp(aCurNode->name,(const xmlChar*)test_cluster))
 147     {
 148       _resource.Clear();
 149       if(ProcessCluster(aCurNode, _resource))
 150       {
 151         std::map<std::string, ParserResourcesType>::const_iterator iter = _resources_list.find(_resource.Name);
 152         if (iter != _resources_list.end())
 153           RES_INFOS("Warning resource " << _resource.Name << " already added, keep last resource found !");
 154         _resources_list[_resource.Name] = _resource;
 155       }
 156     }
 157     aCurNode = aCurNode->next;
 158   }
 159
 160 #ifdef _DEBUG_
 161   for (std::map<std::string, ParserResourcesType>::const_iterator iter = _resources_list.begin();
 162        iter != _resources_list.end();
 163        iter++)
 164   {
 165     std::cerr << "************************************************" << std::endl;
 166     std::cerr << "Resource " << (*iter).first << " found:" << std::endl;
 167     std::cerr << " Name: " << (*iter).second.Name << std::endl;
 168     std::cerr << " Hostname: " << (*iter).second.HostName << std::endl;
 169     std::cerr << " Username: " << (*iter).second.UserName << std::endl;
 170     std::cerr << " Appli path: " <<(*iter).second.AppliPath << std::endl;
 171     std::cerr << " OS: " << (*iter).second.OS << std::endl;
 172     std::cerr << " Protocol: " << (*iter).second.PrintAccessProtocolType() << std::endl;
 173     std::cerr << " Internal Protocol: " <<(*iter).second.PrintClusterInternalProtocol() << std::endl;
 174     std::cerr << " Mode: " << (*iter).second.PrintAccessModeType() << std::endl;
 175     std::cerr << " Batch Type: " << (*iter).second.PrintBatchType() << std::endl;
 176     std::cerr << " MPI Impl: " << (*iter).second.PrintMpiImplType() << std::endl;
 177     std::cerr << "************************************************" << std::endl;
 178   }
 179 #endif
 180 }
 181
 182 bool
 183 SALOME_ResourcesCatalog_Handler::ProcessCluster(xmlNodePtr cluster_descr, ParserResourcesType & resource)
 184 {
 185   // Ajout d'un cluster
 186   // hostname, use et nbOfProc sont obligatoires
 187   if (xmlHasProp(cluster_descr, (const xmlChar*)test_hostname))
 188   {
 189     xmlChar* hostname = xmlGetProp(cluster_descr, (const xmlChar*)test_hostname);
 190     resource.HostName = (const char*)hostname;
 191     xmlFree(hostname);
 192   }
 193   else
 194   {
 195     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! found a cluster without a hostname" << std::endl;
 196     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! this cluster will not be added" << std::endl;
 197     return false;
 198   }
 199
 200   if (xmlHasProp(cluster_descr, (const xmlChar*)test_name))
 201   {
 202     xmlChar* name = xmlGetProp(cluster_descr, (const xmlChar*)test_name);
 203     resource.Name = (const char*)name;
 204     resource.DataForSort._Name = (const char*)name;
 205     xmlFree(name);
 206   }
 207   else
 208   {
 209     resource.Name = resource.HostName;
 210     resource.DataForSort._Name = resource.HostName;
 211     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! No Name found use Hostname for resource: " << _resource.Name << std::endl;
 212   }
 213
 214   if (xmlHasProp(cluster_descr, (const xmlChar*)test_use))
 215   {
 216     xmlChar* use = xmlGetProp(cluster_descr, (const xmlChar*)test_use);
 217     resource.use = (const char*)use;
 218     xmlFree(use);
 219   }
 220   else
 221   {
 222     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! found a cluster without a use" << std::endl;
 223     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! this cluster will not be added" << std::endl;
 224     return false;
 225   }
 226
 227   if (xmlHasProp(cluster_descr, (const xmlChar*)test_nb_of_proc))
 228   {
 229     xmlChar* nb_of_proc = xmlGetProp(cluster_descr, (const xmlChar*)test_nb_of_proc);
 230     resource.nbOfProc = atoi((const char*)nb_of_proc);
 231     xmlFree(nb_of_proc);
 232   }
 233   else
 234   {
 235     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! found a cluster without a nbOfProc" << std::endl;
 236     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! this cluster will not be added" << std::endl;
 237     return false;
 238   }
 239
 240   if (xmlHasProp(cluster_descr, (const xmlChar*)test_mpi))
 241   {
 242     xmlChar* mpi = xmlGetProp(cluster_descr, (const xmlChar*)test_mpi);
 243     std::string anMpi = (const char*)mpi;
 244     xmlFree(mpi);
 245     if (anMpi == "lam")
 246       resource.mpi = lam;
 247     else if (anMpi == "mpich1")
 248       resource.mpi = mpich1;
 249     else if (anMpi == "mpich2")
 250       resource.mpi = mpich2;
 251     else if (anMpi == "openmpi")
 252       resource.mpi = openmpi;
 253     else if  (anMpi == "slurm")
 254       resource.mpi = slurm;
 255     else if  (anMpi == "prun")
 256       resource.mpi = prun;
 257     else
 258       resource.mpi = nompi;
 259   }
 260
 261   // Parsing des membres du cluster
 262   xmlNodePtr aCurSubNode = cluster_descr->xmlChildrenNode;
 263   while(aCurSubNode != NULL)
 264   {
 265     if (!xmlStrcmp(aCurSubNode->name, (const xmlChar*)test_members))
 266     {
 267        xmlNodePtr members = aCurSubNode->xmlChildrenNode;
 268        while (members != NULL)
 269        {
 270          // Process members
 271          if (!xmlStrcmp(members->name, (const xmlChar*)test_machine))
 272          {
 273            ParserResourcesClusterMembersType new_member;
 274            if (ProcessMember(members, new_member))
 275              resource.ClusterMembersList.push_back(new_member);
 276          }
 277          members = members->next;
 278        }
 279     }
 280     aCurSubNode = aCurSubNode->next;
 281   }
 282
 283   // Test: Il faut au moins un membre pour que le cluster soit correct !
 284   if (resource.ClusterMembersList.empty())
 285   {
 286     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! found a cluster without a member" << std::endl;
 287     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! this cluster will not be added" << std::endl;
 288     return false;
 289   }
 290   return true;
 291 }
 292
 293 bool
 294 SALOME_ResourcesCatalog_Handler::ProcessMember(xmlNodePtr member_descr, ParserResourcesClusterMembersType & resource)
 295 {
 296   if (xmlHasProp(member_descr, (const xmlChar*)test_hostname))
 297   {
 298     xmlChar* hostname = xmlGetProp(member_descr, (const xmlChar*)test_hostname);
 299     resource.HostName = (const char*)hostname;
 300     xmlFree(hostname);
 301   }
 302   else
 303   {
 304     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a hostname" << std::endl;
 305     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
 306     return false;
 307   }
 308
 309   if (xmlHasProp(member_descr, (const xmlChar*)test_protocol))
 310   {
 311     xmlChar* protocol= xmlGetProp(member_descr, (const xmlChar*)test_protocol);
 312     switch (protocol[0])
 313     {
 314       case 'r':
 315         resource.Protocol = rsh;
 316         break;
 317       case 's':
 318         resource.Protocol = ssh;
 319         break;
 320       default:
 321         std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine with a bad protocol" << std::endl;
 322         std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
 323         return false;
 324     }
 325     xmlFree(protocol);
 326   }
 327   else
 328   {
 329     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a protocol" << std::endl;
 330     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
 331     return false;
 332   }
 333
 334   if (xmlHasProp(member_descr, (const xmlChar*)test_cluster_internal_protocol))
 335   {
 336     xmlChar* iprotocol= xmlGetProp(member_descr, (const xmlChar*)test_cluster_internal_protocol);
 337     switch (iprotocol[0])
 338     {
 339       case 'r':
 340         resource.ClusterInternalProtocol = rsh;
 341         break;
 342       case 's':
 343         resource.ClusterInternalProtocol = ssh;
 344         break;
 345       default:
 346         std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine with a bad protocol" << std::endl;
 347         std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
 348         return false;
 349     }
 350     xmlFree(iprotocol);
 351   }
 352   else
 353   {
 354     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a protocol" << std::endl;
 355     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
 356     return false;
 357   }
 358
 359   if (xmlHasProp(member_descr, (const xmlChar*)test_user_name))
 360   {
 361     xmlChar* user_name= xmlGetProp(member_descr, (const xmlChar*)test_user_name);
 362     resource.UserName = (const char*)user_name;
 363     xmlFree(user_name);
 364   }
 365   else
 366   {
 367     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a user name" << std::endl;
 368     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
 369     return false;
 370   }
 371
 372   if (xmlHasProp(member_descr, (const xmlChar*)test_nb_of_nodes))
 373   {
 374     xmlChar* nb_of_nodes = xmlGetProp(member_descr, (const xmlChar*)test_nb_of_nodes);
 375     resource.DataForSort._nbOfNodes = atoi((const char*)nb_of_nodes);
 376     xmlFree(nb_of_nodes);
 377   }
 378   else
 379   {
 380     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a nbOfNodes" << std::endl;
 381     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
 382     return false;
 383   }
 384
 385   if (xmlHasProp(member_descr, (const xmlChar*)test_nb_of_proc_per_node))
 386   {
 387     xmlChar* nb_of_proc_per_node = xmlGetProp(member_descr, (const xmlChar*)test_nb_of_proc_per_node);
 388     resource.DataForSort._nbOfProcPerNode = atoi((const char*)nb_of_proc_per_node);
 389     xmlFree(nb_of_proc_per_node);
 390   }
 391   else
 392   {
 393     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a nbOfProcPerNode" << std::endl;
 394     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
 395     return false;
 396   }
 397
 398   if (xmlHasProp(member_descr, (const xmlChar*)test_appli_path))
 399   {
 400     xmlChar* appli_path = xmlGetProp(member_descr, (const xmlChar*)test_appli_path);
 401     resource.AppliPath = (const char*)appli_path;
 402     xmlFree(appli_path);
 403   }
 404   else
 405   {
 406     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a AppliPath" << std::endl;
 407     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
 408     return false;
 409   }
 410   return true;
 411 }
 412
 413 bool
 414 SALOME_ResourcesCatalog_Handler::ProcessMachine(xmlNodePtr machine_descr, ParserResourcesType & resource)
 415 {
 416   if (xmlHasProp(machine_descr, (const xmlChar*)test_hostname))
 417   {
 418     xmlChar* hostname = xmlGetProp(machine_descr, (const xmlChar*)test_hostname);
 419     resource.HostName = (const char*)hostname;
 420     xmlFree(hostname);
 421   }
 422   else
 423   {
 424     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMachine : Warning found a machine without a hostname" << std::endl;
 425     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMachine : Warning this machine will not be added" << std::endl;
 426     return false;
 427   }
 428
 429   if (xmlHasProp(machine_descr, (const xmlChar*)test_name))
 430   {
 431     xmlChar* name = xmlGetProp(machine_descr, (const xmlChar*)test_name);
 432     resource.Name = (const char*)name;
 433     resource.DataForSort._Name = (const char*)name;
 434     xmlFree(name);
 435   }
 436   else
 437   {
 438     resource.Name = resource.HostName;
 439     resource.DataForSort._Name = resource.HostName;
 440     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMachine : !!! Warning !!! No Name found use Hostname for resource: " << _resource.Name << std::endl;
 441   }
 442
 443   if (xmlHasProp(machine_descr, (const xmlChar*)test_batch_queue))
 444   {
 445     xmlChar* batch_queue = xmlGetProp(machine_descr, (const xmlChar*)test_batch_queue);
 446     resource.batchQueue = (const char*)batch_queue;
 447     xmlFree(batch_queue);
 448   }
 449   else
 450     resource.batchQueue = "";
 451
 452   if (xmlHasProp(machine_descr, (const xmlChar*)test_user_commands))
 453   {
 454     xmlChar* user_commands= xmlGetProp(machine_descr, (const xmlChar*)test_user_commands);
 455     resource.userCommands = (const char*)user_commands;
 456     xmlFree(user_commands);
 457   }
 458   else
 459     resource.userCommands = "";
 460
 461   if (xmlHasProp(machine_descr, (const xmlChar*)test_protocol))
 462   {
 463     xmlChar* protocol= xmlGetProp(machine_descr, (const xmlChar*)test_protocol);
 464     switch ( protocol[0])
 465     {
 466       case 'r':
 467         resource.Protocol = rsh;
 468         break;
 469       case 's':
 470         resource.Protocol = ssh;
 471         break;
 472       default:
 473         // If it'not in all theses cases, the protocol is affected to rsh
 474         resource.Protocol = rsh;
 475         break;
 476     }
 477     xmlFree(protocol);
 478   }
 479   else
 480     resource.Protocol = rsh;
 481
 482   if (xmlHasProp(machine_descr, (const xmlChar*)test_cluster_internal_protocol))
 483   {
 484     xmlChar* iprotocol= xmlGetProp(machine_descr, (const xmlChar*)test_cluster_internal_protocol);
 485     switch ( iprotocol[0])
 486     {
 487       case 'r':
 488         resource.ClusterInternalProtocol = rsh;
 489         break;
 490       case 's':
 491         resource.ClusterInternalProtocol = ssh;
 492         break;
 493       default:
 494         // If it'not in all theses cases, the protocol is affected to rsh
 495         resource.ClusterInternalProtocol = rsh;
 496         break;
 497     }
 498     xmlFree(iprotocol);
 499   }
 500   else
 501     resource.ClusterInternalProtocol = resource.Protocol;
 502
 503   if (xmlHasProp(machine_descr, (const xmlChar*)test_mode))
 504   {
 505     xmlChar* mode=xmlGetProp(machine_descr, (const xmlChar*)test_mode);
 506     switch ( mode[0] )
 507     {
 508       case 'i':
 509         resource.Mode = interactive;
 510         break;
 511       case 'b':
 512         resource.Mode = batch;
 513         break;
 514       default:
 515         // If it'not in all theses cases, the mode is affected to interactive
 516         resource.Mode = interactive;
 517         break;
 518     }
 519     xmlFree(mode);
 520   }
 521   else
 522     resource.Mode = interactive;
 523
 524   if (xmlHasProp(machine_descr, (const xmlChar*)test_batch))
 525   {
 526     xmlChar* batch = xmlGetProp(machine_descr, (const xmlChar*)test_batch);
 527     std::string aBatch = (const char*)batch;
 528     xmlFree(batch);
 529     if (aBatch == "pbs")
 530       resource.Batch = pbs;
 531     else if  (aBatch == "lsf")
 532       resource.Batch = lsf;
 533     else if  (aBatch == "sge")
 534       resource.Batch = sge;
 535     else if  (aBatch == "ssh_batch")
 536       resource.Batch = ssh_batch;
 537     else if  (aBatch == "ccc")
 538       resource.Batch = ccc;
 539     else
 540       resource.Batch = none;
 541   }
 542
 543   if (xmlHasProp(machine_descr, (const xmlChar*)test_mpi))
 544   {
 545     xmlChar* mpi = xmlGetProp(machine_descr, (const xmlChar*)test_mpi);
 546     std::string anMpi = (const char*)mpi;
 547     xmlFree(mpi);
 548     if (anMpi == "lam")
 549       resource.mpi = lam;
 550     else if (anMpi == "mpich1")
 551       resource.mpi = mpich1;
 552     else if (anMpi == "mpich2")
 553       resource.mpi = mpich2;
 554     else if (anMpi == "openmpi")
 555       resource.mpi = openmpi;
 556     else if  (anMpi == "slurm")
 557       resource.mpi = slurm;
 558     else if  (anMpi == "prun")
 559       resource.mpi = prun;
 560     else
 561       resource.mpi = nompi;
 562   }
 563
 564   if (xmlHasProp(machine_descr, (const xmlChar*)test_user_name))
 565   {
 566     xmlChar* user_name= xmlGetProp(machine_descr, (const xmlChar*)test_user_name);
 567     resource.UserName = (const char*)user_name;
 568     xmlFree(user_name);
 569   }
 570
 571   if (xmlHasProp(machine_descr, (const xmlChar*)test_appli_path))
 572   {
 573     xmlChar* appli_path = xmlGetProp(machine_descr, (const xmlChar*)test_appli_path);
 574     resource.AppliPath = (const char*)appli_path;
 575     xmlFree(appli_path);
 576   }
 577
 578   if (xmlHasProp(machine_descr, (const xmlChar*)test_os))
 579   {
 580     xmlChar* os = xmlGetProp(machine_descr, (const xmlChar*)test_os);
 581     resource.OS = (const char*)os;
 582     xmlFree(os);
 583   }
 584
 585   if (xmlHasProp(machine_descr, (const xmlChar*)test_mem_in_mb))
 586   {
 587     xmlChar* mem_in_mb = xmlGetProp(machine_descr, (const xmlChar*)test_mem_in_mb);
 588     resource.DataForSort._memInMB = atoi((const char*)mem_in_mb);
 589     xmlFree(mem_in_mb);
 590   }
 591
 592   if (xmlHasProp(machine_descr, (const xmlChar*)test_cpu_freq_mhz))
 593   {
 594     xmlChar* cpu_freq_mhz = xmlGetProp(machine_descr, (const xmlChar*)test_cpu_freq_mhz);
 595     resource.DataForSort._CPUFreqMHz = atoi((const char*)cpu_freq_mhz);
 596     xmlFree(cpu_freq_mhz);
 597   }
 598
 599   if (xmlHasProp(machine_descr, (const xmlChar*)test_nb_of_nodes))
 600   {
 601     xmlChar* nb_of_nodes = xmlGetProp(machine_descr, (const xmlChar*)test_nb_of_nodes);
 602     resource.DataForSort._nbOfNodes = atoi((const char*)nb_of_nodes);
 603     xmlFree(nb_of_nodes);
 604   }
 605
 606   if (xmlHasProp(machine_descr, (const xmlChar*)test_nb_of_proc_per_node))
 607   {
 608     xmlChar* nb_of_proc_per_node = xmlGetProp(machine_descr, (const xmlChar*)test_nb_of_proc_per_node);
 609     resource.DataForSort._nbOfProcPerNode = atoi((const char*)nb_of_proc_per_node);
 610     xmlFree(nb_of_proc_per_node);
 611   }
 612
 613   // Process children nodes
 614   xmlNodePtr aCurSubNode = machine_descr->xmlChildrenNode;
 615   while(aCurSubNode != NULL)
 616   {
 617     // Process components
 618     if ( !xmlStrcmp(aCurSubNode->name, (const xmlChar*)test_components) )
 619     {
 620       //If a component is given, it is in a module with the same name
 621       //except if the module name is given
 622       if (xmlHasProp(aCurSubNode, (const xmlChar*)test_component_name))
 623       {
 624         xmlChar* component_name = xmlGetProp(aCurSubNode, (const xmlChar*)test_component_name);
 625         std::string aComponentName = (const char*)component_name;
 626         _resource.ComponentsList.push_back(aComponentName);
 627         if (xmlHasProp(aCurSubNode, (const xmlChar*)test_module_name))
 628         {
 629           xmlChar* module_name = xmlGetProp(aCurSubNode, (const xmlChar*)test_module_name);
 630           std::string aModuleName = (const char*)module_name;
 631           _resource.ModulesList.push_back(aModuleName);
 632           xmlFree(module_name);
 633         }
 634         else
 635           _resource.ModulesList.push_back(aComponentName);
 636         xmlFree(component_name);
 637       }
 638     }
 639     // Process modules
 640     else if ( !xmlStrcmp(aCurSubNode->name, (const xmlChar*)test_modules) )
 641     {
 642       // If a module is given, we create an entry in componentsList and modulesList
 643       // with the same name (module == component)
 644       if (xmlHasProp(aCurSubNode, (const xmlChar*)test_module_name))
 645       {
 646         xmlChar* component_name = xmlGetProp(aCurSubNode, (const xmlChar*)test_module_name);
 647         std::string aComponentName = (const char*)component_name;
 648         _resource.ComponentsList.push_back(aComponentName);
 649         _resource.ModulesList.push_back(aComponentName);
 650         xmlFree(component_name);
 651       }
 652     }
 653     aCurSubNode = aCurSubNode->next;
 654   }
 655   return true;
 656 }
 657
 658 //=============================================================================
 659 /*!
 660  *  Fill the document tree in xml file, used to write in an xml file.
 661  *  \param theDoc document to fill.
 662  */
 663 //=============================================================================
 664
 665 void SALOME_ResourcesCatalog_Handler::PrepareDocToXmlFile(xmlDocPtr theDoc)
 666 {
 667   // Node pointers
 668   xmlNodePtr root_node = NULL, node = NULL, node1 = NULL;
 669
 670   root_node = xmlNewNode(NULL, BAD_CAST "resources");
 671   xmlDocSetRootElement(theDoc, root_node);
 672
 673   std::map<std::string, ParserResourcesType>::iterator iter = _resources_list.begin();
 674   for (; iter != _resources_list.end(); iter++)
 675   {
 676     node = xmlNewChild(root_node, NULL, BAD_CAST test_machine, NULL);
 677     RES_MESSAGE("Add resource name = " << (*iter).second.Name.c_str());
 678     xmlNewProp(node, BAD_CAST test_name, BAD_CAST (*iter).second.Name.c_str());
 679     xmlNewProp(node, BAD_CAST test_hostname, BAD_CAST (*iter).second.HostName.c_str());
 680     xmlNewProp(node, BAD_CAST test_appli_path, BAD_CAST (*iter).second.AppliPath.c_str());
 681     xmlNewProp(node, BAD_CAST test_batch_queue, BAD_CAST (*iter).second.batchQueue.c_str());
 682     xmlNewProp(node, BAD_CAST test_user_commands, BAD_CAST (*iter).second.userCommands.c_str());
 683
 684     switch ((*iter).second.Protocol)
 685     {
 686       case rsh:
 687         xmlNewProp(node, BAD_CAST test_protocol, BAD_CAST "rsh");
 688         break;
 689       case ssh:
 690         xmlNewProp(node, BAD_CAST test_protocol, BAD_CAST "ssh");
 691         break;
 692       default:
 693         xmlNewProp(node, BAD_CAST test_protocol, BAD_CAST "rsh");
 694     }
 695
 696     switch ((*iter).second.ClusterInternalProtocol)
 697     {
 698       case rsh:
 699         xmlNewProp(node, BAD_CAST test_cluster_internal_protocol, BAD_CAST "rsh");
 700         break;
 701       case ssh:
 702         xmlNewProp(node, BAD_CAST test_cluster_internal_protocol, BAD_CAST "ssh");
 703         break;
 704       default:
 705         xmlNewProp(node, BAD_CAST test_cluster_internal_protocol, BAD_CAST "rsh");
 706     }
 707
 708     switch ((*iter).second.Mode)
 709     {
 710       case interactive:
 711         xmlNewProp(node, BAD_CAST test_mode, BAD_CAST "interactive");
 712         break;
 713       case batch:
 714         xmlNewProp(node, BAD_CAST test_mode, BAD_CAST "batch");
 715         break;
 716       default:
 717         xmlNewProp(node, BAD_CAST test_mode, BAD_CAST "interactive");
 718     }
 719
 720     switch ((*iter).second.Batch)
 721     {
 722       case pbs:
 723         xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "pbs");
 724         break;
 725       case lsf:
 726         xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "lsf");
 727         break;
 728       case sge:
 729         xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "sge");
 730         break;
 731       case ccc:
 732         xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "ccc");
 733         break;
 734       case ssh_batch:
 735         xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "ssh_batch");
 736         break;
 737       default:
 738         xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "");
 739     }
 740
 741     switch ((*iter).second.mpi)
 742     {
 743       case lam:
 744         xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "lam");
 745         break;
 746       case mpich1:
 747         xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "mpich1");
 748         break;
 749       case mpich2:
 750         xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "mpich2");
 751         break;
 752       case openmpi:
 753         xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "openmpi");
 754         break;
 755       case slurm:
 756         xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "slurm");
 757         break;
 758       case prun:
 759         xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "prun");
 760         break;
 761       default:
 762         xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "");
 763     }
 764
 765     xmlNewProp(node, BAD_CAST test_user_name, BAD_CAST (*iter).second.UserName.c_str());
 766
 767     std::vector<std::string>::const_iterator iter2 = (*iter).second.ComponentsList.begin();
 768     for(;iter2 != (*iter).second.ComponentsList.end(); iter2++)
 769     {
 770       node1 = xmlNewChild(node, NULL, BAD_CAST test_components, NULL);
 771       xmlNewProp(node1, BAD_CAST test_component_name, BAD_CAST (*iter2).c_str());
 772     }
 773
 774     xmlNewProp(node, BAD_CAST test_os, BAD_CAST (*iter).second.OS.c_str());
 775     std::ostringstream mem_stream;
 776     mem_stream << (*iter).second.DataForSort._memInMB;
 777     xmlNewProp(node, BAD_CAST test_mem_in_mb, BAD_CAST mem_stream.str().c_str());
 778     std::ostringstream cpu_stream;
 779     cpu_stream << (*iter).second.DataForSort._CPUFreqMHz;
 780     xmlNewProp(node, BAD_CAST test_cpu_freq_mhz, BAD_CAST cpu_stream.str().c_str());
 781     std::ostringstream nb_nodes_stream;
 782     nb_nodes_stream << (*iter).second.DataForSort._nbOfNodes;
 783     xmlNewProp(node, BAD_CAST test_nb_of_nodes, BAD_CAST nb_nodes_stream.str().c_str());
 784     std::ostringstream nb_proc_per_nodes_stream;
 785     nb_proc_per_nodes_stream << (*iter).second.DataForSort._nbOfProcPerNode;
 786     xmlNewProp(node, BAD_CAST test_nb_of_proc_per_node, BAD_CAST nb_proc_per_nodes_stream.str().c_str());
 787   }
 788 }