]> SALOME platform Git repositories - modules/kernel.git/blob - src/ResourcesManager/SALOME_ResourcesCatalog_Handler.cxx
Salome HOME
merge from branch BR_V5_DEV
[modules/kernel.git] / src / ResourcesManager / SALOME_ResourcesCatalog_Handler.cxx
1 //  Copyright (C) 2007-2008  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 //  SALOME ResourcesCatalog : implementation of catalog resources parsing (SALOME_ModuleCatalog.idl)
23 //  File   : SALOME_ResourcesCatalog_Handler.cxx
24 //  Author : Estelle Deville
25 //  Module : SALOME
26 //$Header$
27 //
28 #include "SALOME_ResourcesCatalog_Handler.hxx"
29 #include "Basics_Utils.hxx"
30 #include <iostream>
31 #include <map>
32
33 using namespace std;
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,
44                                 MapOfParserResourcesType& resources_batch_list):
45     _resources_list(resources_list),
46     _resources_batch_list(resources_batch_list)
47 {
48   //XML tags initialisation
49   test_machine = "machine";
50   test_resources = "resources";
51
52   test_hostname = "hostname";
53   test_alias = "alias";
54   test_protocol = "protocol";
55   test_mode = "mode";
56   test_batch = "batch";
57   test_mpi = "mpi";
58   test_user_name = "userName";
59   test_appli_path = "appliPath";
60   test_modules = "modules";
61   test_module_name = "moduleName";
62   test_os = "OS";
63   test_mem_in_mb = "memInMB";
64   test_cpu_freq_mhz = "CPUFreqMHz";
65   test_nb_of_nodes = "nbOfNodes";
66   test_nb_of_proc_per_node = "nbOfProcPerNode";
67   test_batch_queue = "batchQueue";
68   test_user_commands = "userCommands";
69 }
70
71 //=============================================================================
72 /*!
73  *  Destructor
74  */ 
75 //=============================================================================
76
77 SALOME_ResourcesCatalog_Handler::~SALOME_ResourcesCatalog_Handler()
78 {
79   //  cout << "SALOME_ResourcesCatalog_Handler destruction") << endl;
80 }
81
82 //=============================================================================
83 /*!
84  *  Retrieves DS after the file parse.
85  */ 
86 //=============================================================================
87
88 const MapOfParserResourcesType&
89 SALOME_ResourcesCatalog_Handler::GetResourcesAfterParsing() const
90 {
91   return _resources_list;
92 }
93
94 //=============================================================================
95 /*!
96  *  Processes XML document and fills the list of resources
97  */ 
98 //=============================================================================
99
100 void SALOME_ResourcesCatalog_Handler::ProcessXmlDocument(xmlDocPtr theDoc)
101 {
102   // Empty private elements
103   _resources_list.clear();
104
105   // Get the document root node
106   xmlNodePtr aCurNode = xmlDocGetRootElement(theDoc);
107
108   aCurNode = aCurNode->xmlChildrenNode;
109   
110   // Processing the document nodes
111   while(aCurNode != NULL)
112     {
113       if ( !xmlStrcmp(aCurNode->name,(const xmlChar*)test_machine) )
114         {
115           _resource.Clear();
116           if (xmlHasProp(aCurNode, (const xmlChar*)test_hostname))
117             {
118               xmlChar* hostname = xmlGetProp(aCurNode, (const xmlChar*)test_hostname);
119               _resource.DataForSort._hostName = (const char*)hostname;
120               _resource.HostName = (const char*)hostname;
121               xmlFree(hostname);
122             }
123           else
124             break;
125
126           if (xmlHasProp(aCurNode, (const xmlChar*)test_alias))
127             {
128               xmlChar* alias = xmlGetProp(aCurNode, (const xmlChar*)test_alias);
129               _resource.Alias = (const char*)alias;
130               xmlFree(alias);
131             }
132           else
133             _resource.Alias = "";
134
135           if (xmlHasProp(aCurNode, (const xmlChar*)test_batch_queue))
136             {
137               xmlChar* batch_queue = xmlGetProp(aCurNode, (const xmlChar*)test_batch_queue);
138               _resource.batchQueue = (const char*)batch_queue;
139               xmlFree(batch_queue);
140             }
141           else
142             _resource.batchQueue = "";
143
144           if (xmlHasProp(aCurNode, (const xmlChar*)test_user_commands))
145             {
146               xmlChar* user_commands= xmlGetProp(aCurNode, (const xmlChar*)test_user_commands);
147               _resource.userCommands = (const char*)user_commands;
148               xmlFree(user_commands);
149             }
150           else
151             _resource.userCommands = "";
152           
153           if (xmlHasProp(aCurNode, (const xmlChar*)test_protocol))
154             {
155               xmlChar* protocol= xmlGetProp(aCurNode, (const xmlChar*)test_protocol);
156               switch ( protocol[0])
157                 {
158                 case 'r':
159                   _resource.Protocol = rsh;
160                   break;
161                 case 's':
162                   _resource.Protocol = ssh;
163                   break;
164                 default:
165                   // If it'not in all theses cases, the protocol is affected to rsh
166                   _resource.Protocol = rsh;
167                   break;
168                 }
169               xmlFree(protocol);
170             }
171           else
172             _resource.Protocol = rsh;
173           
174           if (xmlHasProp(aCurNode, (const xmlChar*)test_mode))
175             {
176               xmlChar* mode=xmlGetProp(aCurNode, (const xmlChar*)test_mode);
177               switch ( mode[0] )
178                 {
179                 case 'i':
180                   _resource.Mode = interactive;
181                   break;
182                 case 'b':
183                   _resource.Mode = batch;
184                   break;
185                 default:
186                   // If it'not in all theses cases, the mode is affected to interactive
187                   _resource.Mode = interactive;
188                   break;
189                 }
190               xmlFree(mode);
191             }
192           else
193             _resource.Mode = interactive;
194
195           if (xmlHasProp(aCurNode, (const xmlChar*)test_batch))
196             {
197               xmlChar* batch = xmlGetProp(aCurNode, (const xmlChar*)test_batch);
198               std::string aBatch = (const char*)batch;
199               xmlFree(batch);
200               if (aBatch == "pbs")
201                 _resource.Batch = pbs;
202               else if  (aBatch == "lsf")
203                 _resource.Batch = lsf;
204               else if  (aBatch == "sge")
205                 _resource.Batch = sge;
206               else
207                 _resource.Batch = none;
208             }
209
210           if (xmlHasProp(aCurNode, (const xmlChar*)test_mpi))
211             {
212               xmlChar* mpi = xmlGetProp(aCurNode, (const xmlChar*)test_mpi);
213               std::string anMpi = (const char*)mpi;
214               xmlFree(mpi);
215               if (anMpi == "lam")
216                 _resource.mpi = lam;
217               else if (anMpi == "mpich1")
218                 _resource.mpi = mpich1;
219               else if (anMpi == "mpich2")
220                 _resource.mpi = mpich2;
221               else if (anMpi == "openmpi")
222                 _resource.mpi = openmpi;
223               else if  (anMpi == "slurm")
224                 _resource.mpi = slurm;
225               else if  (anMpi == "prun")
226                 _resource.mpi = prun;
227               else
228                 _resource.mpi = nompi;
229             }
230
231           if (xmlHasProp(aCurNode, (const xmlChar*)test_user_name))
232             {
233               xmlChar* user_name= xmlGetProp(aCurNode, (const xmlChar*)test_user_name);
234               _resource.UserName = (const char*)user_name;
235               xmlFree(user_name);
236             }
237           
238           if (xmlHasProp(aCurNode, (const xmlChar*)test_appli_path))
239             {
240               xmlChar* appli_path = xmlGetProp(aCurNode, (const xmlChar*)test_appli_path);
241               _resource.AppliPath = (const char*)appli_path;
242               xmlFree(appli_path);
243             }
244           
245           if (xmlHasProp(aCurNode, (const xmlChar*)test_os))
246             {
247               xmlChar* os = xmlGetProp(aCurNode, (const xmlChar*)test_os);
248               _resource.OS = (const char*)os;
249               xmlFree(os);
250             }
251           
252           if (xmlHasProp(aCurNode, (const xmlChar*)test_mem_in_mb))
253             {
254               xmlChar* mem_in_mb = xmlGetProp(aCurNode, (const xmlChar*)test_mem_in_mb);
255               _resource.DataForSort._memInMB = atoi((const char*)mem_in_mb);
256               xmlFree(mem_in_mb);
257             }
258           
259           if (xmlHasProp(aCurNode, (const xmlChar*)test_cpu_freq_mhz))
260             {
261               xmlChar* cpu_freq_mhz = xmlGetProp(aCurNode, (const xmlChar*)test_cpu_freq_mhz);
262               _resource.DataForSort._CPUFreqMHz = atoi((const char*)cpu_freq_mhz);
263               xmlFree(cpu_freq_mhz);
264             }
265           
266           if (xmlHasProp(aCurNode, (const xmlChar*)test_nb_of_nodes))
267             {
268               xmlChar* nb_of_nodes = xmlGetProp(aCurNode, (const xmlChar*)test_nb_of_nodes);
269               _resource.DataForSort._nbOfNodes = atoi((const char*)nb_of_nodes);
270               xmlFree(nb_of_nodes);
271             }
272           
273           if (xmlHasProp(aCurNode, (const xmlChar*)test_nb_of_proc_per_node))
274             {
275               xmlChar* nb_of_proc_per_node = xmlGetProp(aCurNode, (const xmlChar*)test_nb_of_proc_per_node);
276               _resource.DataForSort._nbOfProcPerNode = atoi((const char*)nb_of_proc_per_node);
277               xmlFree(nb_of_proc_per_node);
278             }
279           
280           // Process modules
281           xmlNodePtr aCurSubNode = aCurNode->xmlChildrenNode;
282           while(aCurSubNode != NULL)
283             {
284               if ( !xmlStrcmp(aCurSubNode->name, (const xmlChar*)test_modules) )
285                 {
286                   if (xmlHasProp(aCurSubNode, (const xmlChar*)test_module_name)) 
287                     {
288                       xmlChar* module_name = xmlGetProp(aCurSubNode, (const xmlChar*)test_module_name);
289                       std::string aModuleName = (const char*)module_name;
290                       _resource.ModulesList.push_back(aModuleName);
291                       xmlFree(module_name);
292                     }
293                 }
294               aCurSubNode = aCurSubNode->next;
295             }
296          
297           // There is two lists
298           // _resources_list for interactive resources
299           // _resources_batch_list for batch resources
300           // This choice is done with Mode parameter
301           if (_resource.Mode == interactive)
302           {
303             int aNbNodes = _resource.DataForSort._nbOfNodes;
304             if( aNbNodes > 1 ){
305               string clusterNode = _resource.DataForSort._hostName ;
306               for( int i=0; i < aNbNodes; i++ ){
307                 char inode[64];
308                 inode[0] = '\0' ;
309                 sprintf(inode,"%s%d",clusterNode.c_str(),i+1);
310                 std::string nodeName(inode);
311                 _resource.DataForSort._hostName = nodeName ;
312                 _resource.HostName = nodeName ;
313                 _resources_list[nodeName] = _resource;
314               }
315             }
316             else
317               {
318                 _resources_list[_resource.HostName] = _resource;
319                 if(_resource.HostName == "localhost")
320                   _resources_list[Kernel_Utils::GetHostname()] = _resource;
321               }
322           }
323           else
324             _resources_batch_list[_resource.HostName] = _resource;
325         }
326       aCurNode = aCurNode->next;
327     }
328
329 #ifdef _DEBUG_
330     for (map<string, ParserResourcesType>::const_iterator iter =
331            _resources_list.begin();
332          iter != _resources_list.end();
333          iter++)
334       {
335         std::cerr << (*iter).second.HostName << std::endl;
336         std::cerr << (*iter).second.Alias << std::endl;
337         std::cerr << (*iter).second.UserName << std::endl;
338         std::cerr << (*iter).second.AppliPath << std::endl;
339         std::cerr << (*iter).second.OS << std::endl;
340         std::cerr << (*iter).second.Protocol << std::endl;
341         std::cerr << (*iter).second.Mode << std::endl;
342       }
343 #endif
344
345 }
346
347
348 //=============================================================================
349 /*!
350  *  Fill the document tree in xml file, used to write in an xml file.
351  *  \param theDoc document to fill.
352  */ 
353 //=============================================================================
354
355 void SALOME_ResourcesCatalog_Handler::PrepareDocToXmlFile(xmlDocPtr theDoc)
356 {
357   // Node pointers
358   xmlNodePtr root_node = NULL, node = NULL, node1 = NULL;
359   char string_buf[80];
360
361   root_node = xmlNewNode(NULL, BAD_CAST "resources");
362   xmlDocSetRootElement(theDoc, root_node);
363     
364   for (map<string, ParserResourcesType>::iterator iter =
365          _resources_list.begin();
366        iter != _resources_list.end();
367        iter++)
368     {
369       node = xmlNewChild(root_node, NULL, BAD_CAST test_machine, NULL);
370       xmlNewProp(node, BAD_CAST test_hostname, BAD_CAST (*iter).second.HostName.c_str());
371       xmlNewProp(node, BAD_CAST test_alias, BAD_CAST (*iter).second.Alias.c_str());
372       xmlNewProp(node, BAD_CAST test_batch_queue, BAD_CAST (*iter).second.batchQueue.c_str());
373       xmlNewProp(node, BAD_CAST test_user_commands, BAD_CAST (*iter).second.userCommands.c_str());
374   
375       switch ((*iter).second.Protocol)
376         {
377         case rsh:
378           xmlNewProp(node, BAD_CAST test_protocol, BAD_CAST "rsh");
379           break;
380         case ssh:
381           xmlNewProp(node, BAD_CAST test_protocol, BAD_CAST "ssh");
382           break;
383         default:
384           xmlNewProp(node, BAD_CAST test_protocol, BAD_CAST "rsh");
385         }
386
387       switch ((*iter).second.Mode)
388         {
389         case interactive:
390           xmlNewProp(node, BAD_CAST test_mode, BAD_CAST "interactive");
391           break;
392         case batch:
393           xmlNewProp(node, BAD_CAST test_mode, BAD_CAST "batch");
394           break;
395         default:
396           xmlNewProp(node, BAD_CAST test_mode, BAD_CAST "interactive");
397         }
398
399       switch ((*iter).second.Batch)
400         {
401         case pbs:
402           xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "pbs");
403           break;
404         case lsf:
405           xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "lsf");
406           break;
407         case sge:
408           xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "sge");
409           break;
410         default:
411           xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "");
412         }
413
414       switch ((*iter).second.mpi)
415         {
416         case lam:
417           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "lam");
418           break;
419         case mpich1:
420           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "mpich1");
421           break;
422         case mpich2:
423           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "mpich2");
424           break;
425         case openmpi:
426           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "openmpi");
427           break;
428         case slurm:
429           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "slurm");
430           break;
431         case prun:
432           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "prun");
433           break;
434         default:
435           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "");
436         }
437
438       xmlNewProp(node, BAD_CAST test_user_name, BAD_CAST (*iter).second.UserName.c_str());
439
440      for (vector<string>::const_iterator iter2 =
441              (*iter).second.ModulesList.begin();
442            iter2 != (*iter).second.ModulesList.end();
443            iter2++)
444         {
445           node1 = xmlNewChild(node, NULL, BAD_CAST test_modules, NULL);
446           xmlNewProp(node1, BAD_CAST test_module_name, BAD_CAST (*iter2).c_str());
447         }
448
449       xmlNewProp(node, BAD_CAST test_os, BAD_CAST (*iter).second.OS.c_str());
450       xmlNewProp(node, BAD_CAST test_mem_in_mb, BAD_CAST sprintf(string_buf, "%u", (*iter).second.DataForSort._memInMB));
451       xmlNewProp(node, BAD_CAST test_cpu_freq_mhz, BAD_CAST sprintf(string_buf, "%u", (*iter).second.DataForSort._CPUFreqMHz));
452       xmlNewProp(node, BAD_CAST test_nb_of_nodes, BAD_CAST sprintf(string_buf, "%u", (*iter).second.DataForSort._nbOfNodes));
453       xmlNewProp(node, BAD_CAST test_nb_of_proc_per_node, BAD_CAST sprintf(string_buf, "%u", (*iter).second.DataForSort._nbOfProcPerNode));
454     }
455   for (map<string, ParserResourcesType>::iterator iter =
456          _resources_batch_list.begin();
457        iter != _resources_batch_list.end();
458        iter++)
459     {
460       node = xmlNewChild(root_node, NULL, BAD_CAST test_machine, NULL);
461       xmlNewProp(node, BAD_CAST test_hostname, BAD_CAST (*iter).second.HostName.c_str());
462       xmlNewProp(node, BAD_CAST test_alias, BAD_CAST (*iter).second.Alias.c_str());
463       
464       switch ((*iter).second.Protocol)
465         {
466         case rsh:
467           xmlNewProp(node, BAD_CAST test_protocol, BAD_CAST "rsh");
468           break;
469         case ssh:
470           xmlNewProp(node, BAD_CAST test_protocol, BAD_CAST "ssh");
471           break;
472         default:
473           xmlNewProp(node, BAD_CAST test_protocol, BAD_CAST "rsh");
474         }
475
476       switch ((*iter).second.Mode)
477         {
478         case interactive:
479           xmlNewProp(node, BAD_CAST test_mode, BAD_CAST "interactive");
480           break;
481         case batch:
482           xmlNewProp(node, BAD_CAST test_mode, BAD_CAST "batch");
483           break;
484         default:
485           xmlNewProp(node, BAD_CAST test_mode, BAD_CAST "interactive");
486         }
487
488       switch ((*iter).second.Batch)
489         {
490         case pbs:
491           xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "pbs");
492           break;
493         case lsf:
494           xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "lsf");
495           break;
496         case sge:
497           xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "sge");
498           break;
499         default:
500           xmlNewProp(node, BAD_CAST test_batch, BAD_CAST "");
501         }
502
503       switch ((*iter).second.mpi)
504         {
505         case lam:
506           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "lam");
507           break;
508         case mpich1:
509           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "mpich1");
510           break;
511         case mpich2:
512           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "mpich2");
513           break;
514         case openmpi:
515           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "openmpi");
516           break;
517         case slurm:
518           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "slurm");
519           break;
520         case prun:
521           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "prun");
522           break;
523         default:
524           xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST "");
525         }
526
527       xmlNewProp(node, BAD_CAST test_user_name, BAD_CAST (*iter).second.UserName.c_str());
528
529      for (vector<string>::const_iterator iter2 =
530              (*iter).second.ModulesList.begin();
531            iter2 != (*iter).second.ModulesList.end();
532            iter2++)
533         {
534           node1 = xmlNewChild(node, NULL, BAD_CAST test_modules, NULL);
535           xmlNewProp(node1, BAD_CAST test_module_name, BAD_CAST (*iter2).c_str());
536         }
537
538       xmlNewProp(node, BAD_CAST test_os, BAD_CAST (*iter).second.OS.c_str());
539       xmlNewProp(node, BAD_CAST test_mem_in_mb, BAD_CAST sprintf(string_buf, "%u", (*iter).second.DataForSort._memInMB));
540       xmlNewProp(node, BAD_CAST test_cpu_freq_mhz, BAD_CAST sprintf(string_buf, "%u", (*iter).second.DataForSort._CPUFreqMHz));
541       xmlNewProp(node, BAD_CAST test_nb_of_nodes, BAD_CAST sprintf(string_buf, "%u", (*iter).second.DataForSort._nbOfNodes));
542       xmlNewProp(node, BAD_CAST test_nb_of_proc_per_node, BAD_CAST sprintf(string_buf, "%u", (*iter).second.DataForSort._nbOfProcPerNode));
543     }
544 }