]> SALOME platform Git repositories - modules/kernel.git/blob - src/ResourcesManager/SALOME_ResourcesCatalog_Handler.cxx
Salome HOME
Merge branch 'V9_9_BR'
[modules/kernel.git] / src / ResourcesManager / SALOME_ResourcesCatalog_Handler.cxx
1 // Copyright (C) 2007-2022  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, or (at your option) any later version.
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 using namespace std;
36
37 //=============================================================================
38 /*!
39  *  Constructor
40  *  \param listOfResources: map of ParserResourcesType to fill when parsing
41  */ 
42 //=============================================================================
43
44 SALOME_ResourcesCatalog_Handler::
45 SALOME_ResourcesCatalog_Handler(MapOfParserResourcesType& resources_list): _resources_list(resources_list)
46 {
47   //XML tags initialisation
48   test_machine = "machine";
49   test_cluster = "cluster";
50   test_name = "name";
51   test_hostname = "hostname";
52   test_type = "type";
53   test_protocol = "protocol";
54   test_cluster_internal_protocol = "iprotocol";
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_components = "component";
63   test_component_name = "name";
64   test_os = "OS";
65   test_mem_in_mb = "memInMB";
66   test_cpu_freq_mhz = "CPUFreqMHz";
67   test_nb_of_nodes = "nbOfNodes";
68   test_nb_of_proc = "nbOfProc";
69   test_nb_of_proc_per_node = "nbOfProcPerNode";
70   test_batch_queue = "batchQueue";
71   test_user_commands = "userCommands";
72   test_use = "use";
73   test_members = "members";
74   test_is_cluster_head = "isClusterHead";
75   test_working_directory = "workingDirectory";
76   test_can_launch_batch_jobs = "canLaunchBatchJobs";
77   test_can_run_containers = "canRunContainers";
78 }
79
80 //=============================================================================
81 /*!
82  *  Destructor
83  */ 
84 //=============================================================================
85
86 SALOME_ResourcesCatalog_Handler::~SALOME_ResourcesCatalog_Handler()
87 {
88   //  cout << "SALOME_ResourcesCatalog_Handler destruction") << endl;
89 }
90
91 //=============================================================================
92 /*!
93  *  Retrieves DS after the file parse.
94  */ 
95 //=============================================================================
96
97 const MapOfParserResourcesType&
98 SALOME_ResourcesCatalog_Handler::GetResourcesAfterParsing() const
99 {
100   return _resources_list;
101 }
102
103 //=============================================================================
104 /*!
105  *  Processes XML document and fills the list of resources
106  */ 
107 //=============================================================================
108
109 void SALOME_ResourcesCatalog_Handler::ProcessXmlDocument(xmlDocPtr theDoc)
110 {
111   // Empty private elements
112   _resources_list.clear();
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     // Declaration of a single machine or a frontal node for a cluster managed by a batch manager
123     if (!xmlStrcmp(aCurNode->name,(const xmlChar*)test_machine))
124     {
125       ParserResourcesType resource;
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         }
134         std::map<std::string, ParserResourcesType>::const_iterator iter = _resources_list.find(resource.Name);
135         if (iter != _resources_list.end())
136           RES_INFOS("Warning resource " << resource.Name << " already added, keep last resource found !");
137         _resources_list[resource.Name] = resource;
138       }
139     }
140     // Declaration of a cluster
141     // Here, a cluster is NOT the frontal node of a cluster managed by a batch manager (classical
142     // usage of a cluster). It is a group of machines intended to be used for a parallel container.
143     // The methods ProcessCluster and ProcessMember are only used in the context of parallel
144     // containers. They are not used in classical Salome usage scenarios.
145     if (!xmlStrcmp(aCurNode->name,(const xmlChar*)test_cluster))
146     {
147       ParserResourcesType resource;
148       if(ProcessCluster(aCurNode, resource))
149       {
150         std::map<std::string, ParserResourcesType>::const_iterator iter = _resources_list.find(resource.Name);
151         if (iter != _resources_list.end())
152           RES_INFOS("Warning resource " << resource.Name << " already added, keep last resource found !");
153         _resources_list[resource.Name] = resource;
154       }
155     }
156     aCurNode = aCurNode->next;
157   }
158
159 #ifdef _DEBUG_
160   for (std::map<std::string, ParserResourcesType>::const_iterator iter = _resources_list.begin();
161        iter != _resources_list.end();
162        iter++)
163   {
164     std::cerr << "************************************************" << std::endl;
165     std::cerr << "Resource " << (*iter).first << " found:" << std::endl;
166     std::cerr << (*iter).second;
167     std::cerr << "************************************************" << std::endl;
168   }
169 #endif
170 }
171
172 bool
173 SALOME_ResourcesCatalog_Handler::ProcessCluster(xmlNodePtr cluster_descr, ParserResourcesType & resource)
174 {
175   // Ajout d'un cluster
176   // hostname, use et nbOfProc sont obligatoires
177   if (xmlHasProp(cluster_descr, (const xmlChar*)test_hostname))
178   {
179     xmlChar* hostname = xmlGetProp(cluster_descr, (const xmlChar*)test_hostname);
180     resource.HostName = (const char*)hostname;
181     xmlFree(hostname);
182   }
183   else
184   {
185     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! found a cluster without a hostname" << std::endl;
186     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! this cluster will not be added" << std::endl;
187     return false;
188   }
189
190   if (xmlHasProp(cluster_descr, (const xmlChar*)test_name))
191   {
192     xmlChar* name = xmlGetProp(cluster_descr, (const xmlChar*)test_name);
193     resource.Name = (const char*)name;
194     resource.DataForSort._Name = (const char*)name;
195     xmlFree(name);
196   }
197   else
198   {
199     resource.Name = resource.HostName;
200     resource.DataForSort._Name = resource.HostName;
201     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! No Name found use Hostname for resource: " << resource.Name << std::endl;
202   }
203
204   if (xmlHasProp(cluster_descr, (const xmlChar*)test_use))
205   {
206     xmlChar* use = xmlGetProp(cluster_descr, (const xmlChar*)test_use);
207     resource.use = (const char*)use;
208     xmlFree(use);
209   }
210   else
211   {
212     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! found a cluster without a use" << std::endl;
213     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! this cluster will not be added" << std::endl;
214     return false;
215   }
216
217   if (xmlHasProp(cluster_descr, (const xmlChar*)test_nb_of_proc))
218   {
219     xmlChar* nb_of_proc = xmlGetProp(cluster_descr, (const xmlChar*)test_nb_of_proc);
220     resource.nbOfProc = atoi((const char*)nb_of_proc);
221     xmlFree(nb_of_proc);
222   }
223   else
224   {
225     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! found a cluster without a nbOfProc" << std::endl;
226     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! this cluster will not be added" << std::endl;
227     return false;
228   }
229
230   if (xmlHasProp(cluster_descr, (const xmlChar*)test_mpi))
231   {
232     xmlChar* mpi = xmlGetProp(cluster_descr, (const xmlChar*)test_mpi);
233     std::string anMpi = (const char*)mpi;
234     xmlFree(mpi);
235     resource.setMpiImplTypeStr(anMpi);
236   }
237
238   // Parsing des membres du cluster 
239   xmlNodePtr aCurSubNode = cluster_descr->xmlChildrenNode;
240   while(aCurSubNode != NULL)
241   {
242     if (!xmlStrcmp(aCurSubNode->name, (const xmlChar*)test_members))
243     {
244        xmlNodePtr members = aCurSubNode->xmlChildrenNode;
245        while (members != NULL)
246        {
247          // Process members
248          if (!xmlStrcmp(members->name, (const xmlChar*)test_machine))
249          {
250            ParserResourcesType new_member;
251            if (ProcessMember(members, new_member))
252              resource.ClusterMembersList.push_back(new_member);
253          }
254          members = members->next;
255        }
256     }
257     aCurSubNode = aCurSubNode->next;
258   }
259
260   // Test: Il faut au moins un membre pour que le cluster soit correct !
261   if (resource.ClusterMembersList.empty())
262   {
263     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! found a cluster without a member" << std::endl;
264     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessCluster : !!! Warning !!! this cluster will not be added" << std::endl;
265     return false;
266   }
267   return true;
268 }
269
270 bool
271 SALOME_ResourcesCatalog_Handler::ProcessMember(xmlNodePtr member_descr, ParserResourcesType & resource)
272 {
273   if (xmlHasProp(member_descr, (const xmlChar*)test_hostname))
274   {
275     xmlChar* hostname = xmlGetProp(member_descr, (const xmlChar*)test_hostname);
276     resource.HostName = (const char*)hostname;
277     xmlFree(hostname);
278   }
279   else
280   {
281     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a hostname" << std::endl;
282     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
283     return false;
284   }
285
286   if (xmlHasProp(member_descr, (const xmlChar*)test_protocol))
287   {
288     xmlChar* protocol= xmlGetProp(member_descr, (const xmlChar*)test_protocol);
289     try
290     {
291       resource.setAccessProtocolTypeStr((const char *)protocol);
292     }
293     catch (const ResourcesException & )
294     {
295       std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine with a bad protocol" << std::endl;
296       std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
297       return false;
298     }
299     xmlFree(protocol);
300   }
301   else
302   {
303     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a protocol" << std::endl;
304     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
305     return false;
306   }
307
308   if (xmlHasProp(member_descr, (const xmlChar*)test_cluster_internal_protocol))
309   {
310     xmlChar* iprotocol= xmlGetProp(member_descr, (const xmlChar*)test_cluster_internal_protocol);
311     try
312     {
313       resource.setClusterInternalProtocolStr((const char *)iprotocol);
314     }
315     catch (const ResourcesException &)
316     {
317       std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine with a bad protocol" << std::endl;
318       std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
319       return false;
320     }
321     xmlFree(iprotocol);
322   }
323   else
324   {
325     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a protocol" << std::endl;
326     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
327     return false;
328   }
329
330   if (xmlHasProp(member_descr, (const xmlChar*)test_user_name))
331   {
332     xmlChar* user_name= xmlGetProp(member_descr, (const xmlChar*)test_user_name);
333     resource.UserName = (const char*)user_name;
334     xmlFree(user_name);
335   }
336   else
337   {
338     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a user name" << std::endl;
339     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
340     return false;
341   }
342
343   if (xmlHasProp(member_descr, (const xmlChar*)test_nb_of_nodes))
344   {
345     xmlChar* nb_of_nodes = xmlGetProp(member_descr, (const xmlChar*)test_nb_of_nodes);
346     resource.DataForSort._nbOfNodes = atoi((const char*)nb_of_nodes);
347     xmlFree(nb_of_nodes);
348   }
349   else
350   {
351     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a nbOfNodes" << std::endl;
352     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
353     return false;
354   }
355
356   if (xmlHasProp(member_descr, (const xmlChar*)test_nb_of_proc_per_node))
357   {
358     xmlChar* nb_of_proc_per_node = xmlGetProp(member_descr, (const xmlChar*)test_nb_of_proc_per_node);
359     resource.DataForSort._nbOfProcPerNode = atoi((const char*)nb_of_proc_per_node);
360     xmlFree(nb_of_proc_per_node);
361   }
362   else
363   {
364     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a nbOfProcPerNode" << std::endl;
365     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
366     return false;
367   }
368
369   if (xmlHasProp(member_descr, (const xmlChar*)test_appli_path))
370   {
371     xmlChar* appli_path = xmlGetProp(member_descr, (const xmlChar*)test_appli_path);
372     resource.AppliPath = (const char*)appli_path;
373     xmlFree(appli_path);
374   }
375   else
376   {
377     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning found a machine without a AppliPath" << std::endl;
378     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMember : Warning this machine will not be added" << std::endl;
379     return false;
380   }
381   return true;
382 }
383
384 bool
385 SALOME_ResourcesCatalog_Handler::ProcessMachine(xmlNodePtr machine_descr, ParserResourcesType & resource)
386 {
387   if (xmlHasProp(machine_descr, (const xmlChar*)test_hostname))
388   {
389     xmlChar* hostname = xmlGetProp(machine_descr, (const xmlChar*)test_hostname);
390     resource.HostName = (const char*)hostname;
391     xmlFree(hostname);
392   }
393   else
394   {
395     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMachine : Warning found a machine without a hostname" << std::endl;
396     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMachine : Warning this machine will not be added" << std::endl;
397     return false;
398   }
399
400   if (xmlHasProp(machine_descr, (const xmlChar*)test_name))
401   {
402     xmlChar* name = xmlGetProp(machine_descr, (const xmlChar*)test_name);
403     resource.Name = (const char*)name;
404     resource.DataForSort._Name = (const char*)name;
405     xmlFree(name);
406   }
407   else
408   {
409     resource.Name = resource.HostName;
410     resource.DataForSort._Name = resource.HostName;
411     std::cerr << "SALOME_ResourcesCatalog_Handler::ProcessMachine : !!! Warning !!! No Name found use Hostname for resource: " << resource.Name << std::endl;
412   }
413
414   // This block is for compatibility with files created in Salome 6.
415   // It can safely be removed in Salome 8.
416   if (xmlHasProp(machine_descr, (const xmlChar*)test_mode))
417   {
418     cerr << "Warning: parameter \"" << test_mode << "\" defined for resource \"" <<
419             resource.Name << "\" is deprecated. It will be replaced when your resource " <<
420             "file is saved." << endl;
421     xmlChar* mode=xmlGetProp(machine_descr, (const xmlChar*)test_mode);
422     switch ( mode[0] )
423     {
424       case 'i':
425         resource.can_run_containers = true;
426         break;
427       case 'b':
428         resource.can_launch_batch_jobs = true;
429         break;
430       default:
431         break;
432     }
433     xmlFree(mode);
434   }
435
436   if (xmlHasProp(machine_descr, (const xmlChar*)test_is_cluster_head))
437   {
438     cerr << "Warning: parameter \"" << test_is_cluster_head << "\" defined for resource \"" <<
439             resource.Name << "\" is deprecated. It will be replaced when your resource " <<
440             "file is saved." << endl;
441     xmlChar* is_cluster_head = xmlGetProp(machine_descr, (const xmlChar*)test_is_cluster_head);
442     std::string str_ich = (const char*)is_cluster_head;
443     if (str_ich == "true")
444     {
445       resource.type = cluster;
446       resource.can_launch_batch_jobs = true;
447       resource.can_run_containers = false;
448     }
449     else
450     {
451       resource.type = single_machine;
452       resource.can_run_containers = true;
453     }
454     xmlFree(is_cluster_head);
455   }
456   // End of compatibility block
457
458   if (xmlHasProp(machine_descr, (const xmlChar*)test_type))
459   {
460     xmlChar* type = xmlGetProp(machine_descr, (const xmlChar*)test_type);
461     try
462     {
463       resource.setResourceTypeStr((const char*)type);
464     }
465     catch (const ResourcesException &)
466     {
467       cerr << "Warning, invalid type \"" << (const char*)type << "\" for resource \"" <<
468               resource.Name << "\", using default value \"" << resource.getResourceTypeStr() <<
469               "\"" << endl;
470     }
471     xmlFree(type);
472   }
473   else
474   {
475     cerr << "Warning, no type found for resource \"" << resource.Name <<
476             "\", using default value \"" << resource.getResourceTypeStr() << "\"" << endl;
477   }
478
479   if (xmlHasProp(machine_descr, (const xmlChar*)test_batch_queue))
480   {
481     xmlChar* batch_queue = xmlGetProp(machine_descr, (const xmlChar*)test_batch_queue);
482     resource.batchQueue = (const char*)batch_queue;
483     xmlFree(batch_queue);
484   }
485
486   if (xmlHasProp(machine_descr, (const xmlChar*)test_user_commands))
487   {
488     xmlChar* user_commands= xmlGetProp(machine_descr, (const xmlChar*)test_user_commands);
489     resource.userCommands = (const char*)user_commands;
490     xmlFree(user_commands);
491   }
492
493   if (xmlHasProp(machine_descr, (const xmlChar*)test_protocol))
494   {
495     xmlChar* protocol= xmlGetProp(machine_descr, (const xmlChar*)test_protocol);
496     try
497     {
498       resource.setAccessProtocolTypeStr((const char *)protocol);
499     }
500     catch (const ResourcesException &)
501     {
502       cerr << "Warning, invalid protocol \"" << (const char*)protocol << "\" for resource \"" <<
503               resource.Name << "\", using default value \"" <<
504               resource.getAccessProtocolTypeStr() << "\"" << endl;
505     }
506     xmlFree(protocol);
507   }
508
509   if (xmlHasProp(machine_descr, (const xmlChar*)test_cluster_internal_protocol))
510   {
511     xmlChar* iprotocol= xmlGetProp(machine_descr, (const xmlChar*)test_cluster_internal_protocol);
512     try
513     {
514       resource.setClusterInternalProtocolStr((const char *)iprotocol);
515     }
516     catch (const ResourcesException &)
517     {
518       cerr << "Warning, invalid internal protocol \"" << (const char*)iprotocol <<
519               "\" for resource \"" << resource.Name << "\", using default value \"" <<
520               resource.getClusterInternalProtocolStr() << "\"" << endl;
521     }
522     xmlFree(iprotocol);
523   }
524   else
525     resource.ClusterInternalProtocol = resource.Protocol;
526
527   if (xmlHasProp(machine_descr, (const xmlChar*)test_batch))
528   {
529     xmlChar* batch = xmlGetProp(machine_descr, (const xmlChar*)test_batch);
530     try
531     {
532       resource.setBatchTypeStr((const char *)batch);
533     }
534     catch (const ResourcesException &)
535     {
536       cerr << "Warning, invalid batch manager \"" << (const char*)batch <<
537               "\" for resource \"" << resource.Name << "\", using default value \"" <<
538               resource.getBatchTypeStr() << "\"" << endl;
539     }
540     xmlFree(batch);
541   }
542
543   if (xmlHasProp(machine_descr, (const xmlChar*)test_mpi))
544   {
545     xmlChar* mpi = xmlGetProp(machine_descr, (const xmlChar*)test_mpi);
546     try
547     {
548       resource.setMpiImplTypeStr((const char *)mpi);
549     }
550     catch (const ResourcesException &)
551     {
552       cerr << "Warning, invalid MPI implementation \"" << (const char*)mpi <<
553               "\" for resource \"" << resource.Name << "\", using default value \"" <<
554               resource.getMpiImplTypeStr() << "\"" << endl;
555     }
556     xmlFree(mpi);
557   }
558
559   if (xmlHasProp(machine_descr, (const xmlChar*)test_user_name))
560   {
561     xmlChar* user_name= xmlGetProp(machine_descr, (const xmlChar*)test_user_name);
562     resource.UserName = (const char*)user_name;
563     xmlFree(user_name);
564   }
565
566   if (xmlHasProp(machine_descr, (const xmlChar*)test_appli_path))
567   {
568     xmlChar* appli_path = xmlGetProp(machine_descr, (const xmlChar*)test_appli_path);
569     resource.AppliPath = (const char*)appli_path;
570     xmlFree(appli_path);
571   }
572
573   if (xmlHasProp(machine_descr, (const xmlChar*)test_os))
574   {
575     xmlChar* os = xmlGetProp(machine_descr, (const xmlChar*)test_os);
576     resource.OS = (const char*)os;
577     xmlFree(os);
578   }
579
580   if (xmlHasProp(machine_descr, (const xmlChar*)test_mem_in_mb))
581   {
582     xmlChar* mem_in_mb = xmlGetProp(machine_descr, (const xmlChar*)test_mem_in_mb);
583     resource.DataForSort._memInMB = atoi((const char*)mem_in_mb);
584     xmlFree(mem_in_mb);
585   }
586
587   if (xmlHasProp(machine_descr, (const xmlChar*)test_cpu_freq_mhz))
588   {
589     xmlChar* cpu_freq_mhz = xmlGetProp(machine_descr, (const xmlChar*)test_cpu_freq_mhz);
590     resource.DataForSort._CPUFreqMHz = atoi((const char*)cpu_freq_mhz);
591     xmlFree(cpu_freq_mhz);
592   }
593
594   if (xmlHasProp(machine_descr, (const xmlChar*)test_nb_of_nodes))
595   {
596     xmlChar* nb_of_nodes = xmlGetProp(machine_descr, (const xmlChar*)test_nb_of_nodes);
597     resource.DataForSort._nbOfNodes = atoi((const char*)nb_of_nodes);
598     xmlFree(nb_of_nodes);
599   }
600
601   if (xmlHasProp(machine_descr, (const xmlChar*)test_nb_of_proc_per_node))
602   {
603     xmlChar* nb_of_proc_per_node = xmlGetProp(machine_descr, (const xmlChar*)test_nb_of_proc_per_node);
604     resource.DataForSort._nbOfProcPerNode = atoi((const char*)nb_of_proc_per_node);
605     xmlFree(nb_of_proc_per_node);
606   }
607
608   if (xmlHasProp(machine_descr, (const xmlChar*)test_can_launch_batch_jobs))
609   {
610     xmlChar* can_launch_batch_jobs = xmlGetProp(machine_descr, (const xmlChar*)test_can_launch_batch_jobs);
611     try
612     {
613       resource.setCanLaunchBatchJobsStr((const char *)can_launch_batch_jobs);
614     }
615     catch (const ResourcesException &)
616     {
617       cerr << "Warning, invalid can_launch_batch_jobs parameter value \"" <<
618               (const char*)can_launch_batch_jobs << "\" for resource \"" << resource.Name <<
619               "\", using default value \"" << resource.getCanLaunchBatchJobsStr() << "\"" << endl;
620     }
621     xmlFree(can_launch_batch_jobs);
622   }
623
624   if (xmlHasProp(machine_descr, (const xmlChar*)test_can_run_containers))
625   {
626     xmlChar* can_run_containers = xmlGetProp(machine_descr, (const xmlChar*)test_can_run_containers);
627     try
628     {
629       resource.setCanRunContainersStr((const char *)can_run_containers);
630     }
631     catch (const ResourcesException &)
632     {
633       cerr << "Warning, invalid can_run_containers parameter value \"" <<
634               (const char*)can_run_containers << "\" for resource \"" << resource.Name <<
635               "\", using default value \"" << resource.getCanRunContainersStr() << "\"" << endl;
636     }
637     xmlFree(can_run_containers);
638   }
639
640   if (xmlHasProp(machine_descr, (const xmlChar*)test_working_directory))
641   {
642     xmlChar* working_directory = xmlGetProp(machine_descr, (const xmlChar*)test_working_directory);
643     resource.working_directory = (const char*)working_directory;
644     xmlFree(working_directory);
645   }
646
647   // Process children nodes
648   xmlNodePtr aCurSubNode = machine_descr->xmlChildrenNode;
649   while(aCurSubNode != NULL)
650   {
651     // Process components
652     if ( !xmlStrcmp(aCurSubNode->name, (const xmlChar*)test_components) )
653     {
654       //If a component is given, it is in a module with the same name
655       //except if the module name is given
656       if (xmlHasProp(aCurSubNode, (const xmlChar*)test_component_name)) 
657       {
658         xmlChar* component_name = xmlGetProp(aCurSubNode, (const xmlChar*)test_component_name);
659         std::string aComponentName = (const char*)component_name;
660         resource.ComponentsList.push_back(aComponentName);
661         if (xmlHasProp(aCurSubNode, (const xmlChar*)test_module_name)) 
662         {
663           xmlChar* module_name = xmlGetProp(aCurSubNode, (const xmlChar*)test_module_name);
664           std::string aModuleName = (const char*)module_name;
665           resource.ModulesList.push_back(aModuleName);
666           xmlFree(module_name);
667         }
668         else
669           resource.ModulesList.push_back(aComponentName);
670         xmlFree(component_name);
671       }
672     }
673     // Process modules
674     else if ( !xmlStrcmp(aCurSubNode->name, (const xmlChar*)test_modules) )
675     {
676       // If a module is given, we create an entry in componentsList and modulesList
677       // with the same name (module == component)
678       if (xmlHasProp(aCurSubNode, (const xmlChar*)test_module_name)) 
679       {
680         xmlChar* component_name = xmlGetProp(aCurSubNode, (const xmlChar*)test_module_name);
681         std::string aComponentName = (const char*)component_name;
682         resource.ComponentsList.push_back(aComponentName);
683         resource.ModulesList.push_back(aComponentName);
684         xmlFree(component_name);
685       }
686     }
687     aCurSubNode = aCurSubNode->next;
688   }
689   return true;
690 }
691
692 //=============================================================================
693 /*!
694  *  Fill the document tree in xml file, used to write in an xml file.
695  *  \param theDoc document to fill.
696  */ 
697 //=============================================================================
698
699 void SALOME_ResourcesCatalog_Handler::PrepareDocToXmlFile(xmlDocPtr theDoc)
700 {
701   // Node pointers
702   xmlNodePtr root_node = NULL, node = NULL, node1 = NULL;
703
704   root_node = xmlNewNode(NULL, BAD_CAST "resources");
705   xmlDocSetRootElement(theDoc, root_node);
706     
707   std::map<std::string, ParserResourcesType>::iterator iter = _resources_list.begin();
708   for (; iter != _resources_list.end(); iter++)
709   {
710     node = xmlNewChild(root_node, NULL, BAD_CAST test_machine, NULL);
711     RES_MESSAGE("Add resource name = " << (*iter).second.Name.c_str());
712     xmlNewProp(node, BAD_CAST test_name, BAD_CAST (*iter).second.Name.c_str());
713     xmlNewProp(node, BAD_CAST test_hostname, BAD_CAST (*iter).second.HostName.c_str());
714     xmlNewProp(node, BAD_CAST test_type, BAD_CAST (*iter).second.getResourceTypeStr().c_str());
715     xmlNewProp(node, BAD_CAST test_appli_path, BAD_CAST (*iter).second.AppliPath.c_str());
716     xmlNewProp(node, BAD_CAST test_batch_queue, BAD_CAST (*iter).second.batchQueue.c_str());
717     xmlNewProp(node, BAD_CAST test_user_commands, BAD_CAST (*iter).second.userCommands.c_str());
718     xmlNewProp(node, BAD_CAST test_protocol, BAD_CAST (*iter).second.getAccessProtocolTypeStr().c_str());
719     xmlNewProp(node, BAD_CAST test_cluster_internal_protocol,
720                BAD_CAST (*iter).second.getClusterInternalProtocolStr().c_str());
721     xmlNewProp(node, BAD_CAST test_working_directory, BAD_CAST (*iter).second.working_directory.c_str());
722     xmlNewProp(node, BAD_CAST test_can_launch_batch_jobs,
723                BAD_CAST (*iter).second.getCanLaunchBatchJobsStr().c_str());
724     xmlNewProp(node, BAD_CAST test_can_run_containers,
725                BAD_CAST (*iter).second.getCanRunContainersStr().c_str());
726     xmlNewProp(node, BAD_CAST test_batch, BAD_CAST (*iter).second.getBatchTypeStr().c_str());
727     xmlNewProp(node, BAD_CAST test_mpi, BAD_CAST (*iter).second.getMpiImplTypeStr().c_str());
728     xmlNewProp(node, BAD_CAST test_user_name, BAD_CAST (*iter).second.UserName.c_str());
729
730     std::vector<std::string>::const_iterator iter2 = (*iter).second.ComponentsList.begin();
731     for(;iter2 != (*iter).second.ComponentsList.end(); iter2++)
732     {
733       node1 = xmlNewChild(node, NULL, BAD_CAST test_components, NULL);
734       xmlNewProp(node1, BAD_CAST test_component_name, BAD_CAST (*iter2).c_str());
735     }
736
737     xmlNewProp(node, BAD_CAST test_os, BAD_CAST (*iter).second.OS.c_str());
738     std::ostringstream mem_stream;
739     mem_stream << (*iter).second.DataForSort._memInMB;
740     xmlNewProp(node, BAD_CAST test_mem_in_mb, BAD_CAST mem_stream.str().c_str());
741     std::ostringstream cpu_stream;
742     cpu_stream << (*iter).second.DataForSort._CPUFreqMHz;
743     xmlNewProp(node, BAD_CAST test_cpu_freq_mhz, BAD_CAST cpu_stream.str().c_str());
744     std::ostringstream nb_nodes_stream;
745     nb_nodes_stream << (*iter).second.DataForSort._nbOfNodes;
746     xmlNewProp(node, BAD_CAST test_nb_of_nodes, BAD_CAST nb_nodes_stream.str().c_str());
747     std::ostringstream nb_proc_per_nodes_stream;
748     nb_proc_per_nodes_stream << (*iter).second.DataForSort._nbOfProcPerNode;
749     xmlNewProp(node, BAD_CAST test_nb_of_proc_per_node, BAD_CAST nb_proc_per_nodes_stream.str().c_str());
750   }
751 }