]> SALOME platform Git repositories - modules/kernel.git/blob - src/Container/Salome_file_i.cxx
Salome HOME
Copyright update 2020
[modules/kernel.git] / src / Container / Salome_file_i.cxx
1 // Copyright (C) 2007-2020  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 //  File   : Salome_file_i.cxx
21 //  Author : André RIBES, EDF
22 //  Module : SALOME
23 //  $Header: 
24 //
25 #include "Salome_file_i.hxx"
26 #include "utilities.h"
27 #include <stdlib.h>
28 #include "HDFOI.hxx"
29 #ifndef WIN32
30 # include <unistd.h>
31 # define _getcwd getcwd
32 # define _open   open
33 #else
34 # include <direct.h>
35 # include <io.h>
36 # include <windows.h>
37 #endif
38
39 /*! \class Salome_file_i
40  *  \brief A class to manage file transfer in %SALOME
41  *
42  */
43
44
45 //=============================================================================
46 /*! 
47  *  Default constructor,
48  */
49 //=============================================================================
50
51 Salome_file_i::Salome_file_i()
52 {
53   _fileId = 0;
54 #ifndef WIN32
55   _path_max = 1 + pathconf("/", _PC_PATH_MAX);
56 #else
57   _path_max = 32768;
58   //from MSDN:
59   //Note The C Runtime supports path lengths up to 32768 characters in length, but it is up to the operating system, specifically the file system, to support these longer paths. The sum of the fields should not exceed _MAX_PATH for full backwards compatibility with Windows 98 FAT32 file systems. Windows NT 4.0, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003, and Windows Server 2003 NTFS file system supports paths up to 32768 characters in length, but only when using the Unicode APIs. When using long path names, prefix the path with the characters \\?\ and use the Unicode versions of the C Runtime functions.
60   //currently #define _MAX_PATH   260
61 #endif
62   _state.name = CORBA::string_dup("");
63   _state.hdf5_file_name = CORBA::string_dup("");
64   _state.number_of_files = 0;
65   _state.files_ok = true;
66   _container = Engines::Container::_nil();
67   _default_source_Salome_file = Engines::Salome_file::_nil();
68 }
69
70 //=============================================================================
71 /*! 
72  *  Destructor
73  */
74 //=============================================================================
75
76 Salome_file_i::~Salome_file_i()
77 {
78 }
79
80 //=============================================================================
81 /*! 
82  *  CORBA method
83  * \see Engines::Salome_file::load
84  */
85 //=============================================================================
86 void 
87 Salome_file_i::load(const char* hdf5_file) {
88   _state.hdf5_file_name = CORBA::string_dup(hdf5_file);
89   try
90   {
91     HDFfile *hdf_file;
92     HDFgroup *hdf_group;
93     HDFdataset *hdf_dataset;
94     int size;
95     int fd;
96     char * value;
97     char * buffer;
98
99     hdf_file = new HDFfile((char*) hdf5_file);
100     hdf_file->OpenOnDisk(HDF_RDONLY);
101
102     hdf_group = new HDFgroup("CONFIG",hdf_file); 
103     hdf_group->OpenOnDisk();
104     hdf_dataset = new HDFdataset("MODE",hdf_group);
105     hdf_dataset->OpenOnDisk();
106     size = hdf_dataset->GetSize();
107     value = new char[size];
108     hdf_dataset->ReadFromDisk(value);
109     hdf_dataset->CloseOnDisk();
110     std::string mode(value);
111     delete value;
112     
113     hdf_group = new HDFgroup("GROUP_FILES",hdf_file); 
114     hdf_group->OpenOnDisk();
115     hdf_dataset = new HDFdataset("LIST_OF_FILES",hdf_group);
116     hdf_dataset->OpenOnDisk();
117     size = hdf_dataset->GetSize();
118     value = new char[size];
119     hdf_dataset->ReadFromDisk(value);
120     hdf_dataset->CloseOnDisk();
121     std::string list_of_files(value);
122     delete value;
123
124     std::istringstream iss(list_of_files);
125     std::string file_name;
126     while (std::getline(iss, file_name, ' '))
127     {
128       std::string dataset_group_name("DATASET");
129       dataset_group_name += file_name;
130
131       hdf_group = new HDFgroup(dataset_group_name.c_str(), hdf_file); 
132       hdf_group->OpenOnDisk();
133
134       hdf_dataset = new HDFdataset("NAME",hdf_group);
135       hdf_dataset->OpenOnDisk();
136       size = hdf_dataset->GetSize();
137       value = new char[size];
138       hdf_dataset->ReadFromDisk(value);
139       hdf_dataset->CloseOnDisk();
140       std::string name(value);
141
142       hdf_dataset = new HDFdataset("PATH",hdf_group);
143       hdf_dataset->OpenOnDisk();
144       size = hdf_dataset->GetSize();
145       value = new char[size];
146       hdf_dataset->ReadFromDisk(value);
147       hdf_dataset->CloseOnDisk();
148       std::string path(value);
149
150       hdf_dataset = new HDFdataset("TYPE",hdf_group);
151       hdf_dataset->OpenOnDisk();
152       size = hdf_dataset->GetSize();
153       value = new char[size];
154       hdf_dataset->ReadFromDisk(value);
155       hdf_dataset->CloseOnDisk();
156       std::string type(value);
157
158       hdf_dataset = new HDFdataset("SOURCE_FILE_NAME",hdf_group);
159       hdf_dataset->OpenOnDisk();
160       size = hdf_dataset->GetSize();
161       value = new char[size];
162       hdf_dataset->ReadFromDisk(value);
163       hdf_dataset->CloseOnDisk();
164       std::string source_file_name(value);
165
166       hdf_dataset = new HDFdataset("STATUS",hdf_group);
167       hdf_dataset->OpenOnDisk();
168       size = hdf_dataset->GetSize();
169       value = new char[size];
170       hdf_dataset->ReadFromDisk(value);
171       hdf_dataset->CloseOnDisk();
172       std::string status(value);
173
174       if (mode == "all") {
175
176         // Changing path, is now current directory
177         path = getcwd(NULL, _path_max);
178   
179         std::string group_name("GROUP");
180         group_name += file_name;
181         hdf_group = new HDFgroup(group_name.c_str(),hdf_file); 
182         hdf_group->OpenOnDisk();
183         hdf_dataset = new HDFdataset("FILE DATASET",hdf_group);
184         hdf_dataset->OpenOnDisk();
185         size = hdf_dataset->GetSize();
186         buffer = new char[size];
187       
188         if ( (fd = ::open(file_name.c_str(),O_RDWR|O_CREAT,00666)) <0) { 
189           SALOME::ExceptionStruct es;
190           es.type = SALOME::INTERNAL_ERROR;
191           std::string text = "open failed";
192           es.text = CORBA::string_dup(text.c_str());
193           throw SALOME::SALOME_Exception(es);
194         };
195         hdf_dataset->ReadFromDisk(buffer);
196         if ( write(fd,buffer,size) <0) { 
197           SALOME::ExceptionStruct es;
198           es.type = SALOME::INTERNAL_ERROR;
199           std::string text = "write failed";
200           es.text = CORBA::string_dup(text.c_str());
201           throw SALOME::SALOME_Exception(es);
202         };
203         // Close the target file
204         ::close(fd);
205
206         Engines::file infos;
207         infos.file_name = CORBA::string_dup(file_name.c_str());
208         infos.path = CORBA::string_dup(path.c_str());
209         infos.type = CORBA::string_dup(type.c_str());
210         infos.source_file_name = CORBA::string_dup(source_file_name.c_str());
211         infos.status = CORBA::string_dup(status.c_str());
212
213         _fileManaged[file_name] = infos;
214
215         // Update Salome_file state
216         _state.number_of_files++;
217         _state.files_ok = true;
218       }
219       else {
220         Engines::file infos;
221         infos.file_name = CORBA::string_dup(file_name.c_str());
222         infos.path = CORBA::string_dup(path.c_str());
223         infos.type = CORBA::string_dup(type.c_str());
224         infos.source_file_name = CORBA::string_dup(source_file_name.c_str());
225         infos.status = CORBA::string_dup(status.c_str());
226         // Infos for parallel extensions...
227         infos.node = 0;
228         infos.container = Engines::Container::_duplicate(_container);
229
230         _fileManaged[file_name] = infos;
231
232         // Update Salome_file state
233         _state.number_of_files++;
234         if (status != "ok")
235           _state.files_ok = false;
236       }
237     }
238   }
239   catch (HDFexception)
240   {
241     SALOME::ExceptionStruct es;
242     es.type = SALOME::INTERNAL_ERROR;
243     std::string text = "!!!! HDFexception";
244     es.text = CORBA::string_dup(text.c_str());
245     throw SALOME::SALOME_Exception(es);
246   }
247 }
248
249 //=============================================================================
250 /*! 
251  *  CORBA method
252  * \see Engines::Salome_file::save
253  */
254 //=============================================================================
255 void 
256 Salome_file_i::save(const char* hdf5_file) {
257   _state.hdf5_file_name = CORBA::string_dup(hdf5_file);
258   try
259   {
260     HDFfile *hdf_file;
261     HDFgroup *hdf_group;
262     HDFdataset *hdf_dataset;
263     hdf_size size[1];
264     _t_fileManaged::iterator begin = _fileManaged.begin();
265     _t_fileManaged::iterator end = _fileManaged.end();
266
267     hdf_file = new HDFfile((char*) _state.hdf5_file_name.in());
268     hdf_file->CreateOnDisk();
269
270     // Save mode information
271     hdf_group = new HDFgroup("CONFIG", hdf_file);
272     hdf_group->CreateOnDisk();
273     std::string mode("infos");
274     size[0] = strlen(mode.c_str()) + 1;
275     hdf_dataset = new HDFdataset("MODE", hdf_group, HDF_STRING, size, 1);
276     hdf_dataset->CreateOnDisk();
277     hdf_dataset->WriteOnDisk((void *) mode.c_str());
278     hdf_dataset->CloseOnDisk();
279     hdf_group->CloseOnDisk();
280
281     // List of files that are managed
282     std::string list_of_files;
283     for(;begin!=end;begin++) 
284     {
285       Engines::file file_infos = begin->second;
286       std::string file_name(file_infos.file_name.in());
287
288       list_of_files = list_of_files + file_name + std::string(" ");
289     }
290     hdf_group = new HDFgroup("GROUP_FILES", hdf_file);
291     hdf_group->CreateOnDisk();
292     size[0] = strlen(list_of_files.c_str()) + 1;
293     hdf_dataset = new HDFdataset("LIST_OF_FILES", hdf_group, HDF_STRING, size, 1);
294     hdf_dataset->CreateOnDisk();
295     hdf_dataset->WriteOnDisk((void *) list_of_files.c_str());
296     hdf_dataset->CloseOnDisk();
297     hdf_group->CloseOnDisk();
298
299     // Insert Files into the hdf5_file
300     begin = _fileManaged.begin();
301     for(;begin!=end;begin++) 
302     {
303       Engines::file file_infos = begin->second;
304       std::string file_name(file_infos.file_name.in());
305       std::string comp_file_name(_fileManaged[file_name].path.in());
306       comp_file_name.append(_fileManaged[file_name].file_name.in());
307       std::string dataset_group_name("DATASET");
308       dataset_group_name += std::string(_fileManaged[file_name].file_name.in());
309
310       hdf_group = new HDFgroup((char *) dataset_group_name.c_str(), hdf_file);
311       hdf_group->CreateOnDisk();
312       size[0] = strlen(file_infos.file_name.in()) + 1;
313       hdf_dataset = new HDFdataset("NAME", hdf_group, HDF_STRING, size, 1);
314       hdf_dataset->CreateOnDisk();
315       hdf_dataset->WriteOnDisk((void *) file_infos.file_name.in());
316       hdf_dataset->CloseOnDisk();
317       size[0] = strlen(file_infos.path.in()) + 1;
318       hdf_dataset = new HDFdataset("PATH", hdf_group, HDF_STRING, size, 1);
319       hdf_dataset->CreateOnDisk();
320       hdf_dataset->WriteOnDisk((void *) file_infos.path.in());
321       hdf_dataset->CloseOnDisk();
322       size[0] = strlen(file_infos.type.in()) + 1;
323       hdf_dataset = new HDFdataset("TYPE", hdf_group, HDF_STRING, size, 1);
324       hdf_dataset->CreateOnDisk();
325       hdf_dataset->WriteOnDisk((void *) file_infos.type.in());
326       hdf_dataset->CloseOnDisk();
327       size[0] = strlen(file_infos.source_file_name.in()) + 1;
328       hdf_dataset = new HDFdataset("SOURCE_FILE_NAME", hdf_group, HDF_STRING, size, 1);
329       hdf_dataset->CreateOnDisk();
330       hdf_dataset->WriteOnDisk((void *) file_infos.source_file_name.in());
331       hdf_dataset->CloseOnDisk();
332       size[0] = strlen(file_infos.status.in()) + 1;
333       hdf_dataset = new HDFdataset("STATUS", hdf_group, HDF_STRING, size, 1);
334       hdf_dataset->CreateOnDisk();
335       hdf_dataset->WriteOnDisk((void *) file_infos.status.in());
336       hdf_dataset->CloseOnDisk();
337       hdf_group->CloseOnDisk();
338     }
339
340     hdf_file->CloseOnDisk();
341
342     //      delete hdf_dataset;
343     //      delete hdf_group; ----> SEGFAULT !!!
344     //      delete hdf_file; ----> SEGFAULT !!!
345   }
346   catch (HDFexception)
347   {
348     SALOME::ExceptionStruct es;
349     es.type = SALOME::INTERNAL_ERROR;
350     std::string text = "!!!! HDFexception";
351     es.text = CORBA::string_dup(text.c_str());
352     throw SALOME::SALOME_Exception(es);
353   }
354 }
355
356 //=============================================================================
357 /*! 
358  *  CORBA method
359  * \see Engines::Salome_file::save_all
360  */
361 //=============================================================================
362 void 
363 Salome_file_i::save_all(const char* hdf5_file) {
364
365   _state.hdf5_file_name = CORBA::string_dup(hdf5_file);
366   // Test Salome_file status
367   if (_state.files_ok == false) {
368     SALOME::ExceptionStruct es;
369     es.type = SALOME::INTERNAL_ERROR;
370     std::string text = "File Not Ok !";
371     es.text = CORBA::string_dup(text.c_str());
372     throw SALOME::SALOME_Exception(es);
373   }
374
375   // For each file we create two groups
376   // First group contains file's information
377   // Second group contains the file
378   // At the end we create a group and a dataset containing the names
379   // of all the files.
380   try
381   {
382     HDFfile *hdf_file;
383     HDFgroup *hdf_group;
384     HDFdataset *hdf_dataset;
385     hdf_size size[1];
386     _t_fileManaged::iterator begin = _fileManaged.begin();
387     _t_fileManaged::iterator end = _fileManaged.end();
388
389     hdf_file = new HDFfile((char*) _state.hdf5_file_name.in());
390     hdf_file->CreateOnDisk();
391
392     // Save mode information
393     hdf_group = new HDFgroup("CONFIG", hdf_file);
394     hdf_group->CreateOnDisk();
395     std::string mode("all");
396     size[0] = strlen(mode.c_str()) + 1;
397     hdf_dataset = new HDFdataset("MODE", hdf_group, HDF_STRING, size, 1);
398     hdf_dataset->CreateOnDisk();
399     hdf_dataset->WriteOnDisk((void *) mode.c_str());
400     hdf_dataset->CloseOnDisk();
401     hdf_group->CloseOnDisk();
402
403
404     // List of files that will be inserted
405     std::string list_of_files;
406     for(;begin!=end;begin++) 
407     {
408       Engines::file file_infos = begin->second;
409       std::string file_name(file_infos.file_name.in());
410
411       list_of_files = list_of_files + file_name + std::string(" ");
412     }
413     hdf_group = new HDFgroup("GROUP_FILES", hdf_file);
414     hdf_group->CreateOnDisk();
415     size[0] = strlen(list_of_files.c_str()) + 1;
416     hdf_dataset = new HDFdataset("LIST_OF_FILES", hdf_group, HDF_STRING, size, 1);
417     hdf_dataset->CreateOnDisk();
418     hdf_dataset->WriteOnDisk((void *) list_of_files.c_str());
419     hdf_dataset->CloseOnDisk();
420     hdf_group->CloseOnDisk();
421
422     // Insert Files into the hdf5_file
423     begin = _fileManaged.begin();
424     for(;begin!=end;begin++) 
425     {
426       Engines::file file_infos = begin->second;
427       std::string file_name(file_infos.file_name.in());
428       std::string comp_file_name(_fileManaged[file_name].path.in());
429       comp_file_name.append(_fileManaged[file_name].file_name.in());
430       std::string group_name("GROUP");
431       group_name += std::string(_fileManaged[file_name].file_name.in());
432       std::string dataset_group_name("DATASET");
433       dataset_group_name += std::string(_fileManaged[file_name].file_name.in());
434
435       hdf_group = new HDFgroup((char *) group_name.c_str(), hdf_file);
436       hdf_group->CreateOnDisk();
437       HDFConvert::FromAscii(comp_file_name.c_str(), *hdf_group, "FILE DATASET");
438       hdf_group->CloseOnDisk();
439
440       hdf_group = new HDFgroup((char *) dataset_group_name.c_str(), hdf_file);
441       hdf_group->CreateOnDisk();
442       size[0] = strlen(file_infos.file_name.in()) + 1;
443       hdf_dataset = new HDFdataset("NAME", hdf_group, HDF_STRING, size, 1);
444       hdf_dataset->CreateOnDisk();
445       hdf_dataset->WriteOnDisk((void *) file_infos.file_name.in());
446       hdf_dataset->CloseOnDisk();
447       size[0] = strlen(file_infos.path.in()) + 1;
448       hdf_dataset = new HDFdataset("PATH", hdf_group, HDF_STRING, size, 1);
449       hdf_dataset->CreateOnDisk();
450       hdf_dataset->WriteOnDisk((void *) file_infos.path.in());
451       hdf_dataset->CloseOnDisk();
452       size[0] = strlen(file_infos.type.in()) + 1;
453       hdf_dataset = new HDFdataset("TYPE", hdf_group, HDF_STRING, size, 1);
454       hdf_dataset->CreateOnDisk();
455       hdf_dataset->WriteOnDisk((void *) file_infos.type.in());
456       hdf_dataset->CloseOnDisk();
457       size[0] = strlen(file_infos.source_file_name.in()) + 1;
458       hdf_dataset = new HDFdataset("SOURCE_FILE_NAME", hdf_group, HDF_STRING, size, 1);
459       hdf_dataset->CreateOnDisk();
460       hdf_dataset->WriteOnDisk((void *) file_infos.source_file_name.in());
461       hdf_dataset->CloseOnDisk();
462       size[0] = strlen(file_infos.status.in()) + 1;
463       hdf_dataset = new HDFdataset("STATUS", hdf_group, HDF_STRING, size, 1);
464       hdf_dataset->CreateOnDisk();
465       hdf_dataset->WriteOnDisk((void *) file_infos.status.in());
466       hdf_dataset->CloseOnDisk();
467       hdf_group->CloseOnDisk();
468
469     }
470
471     hdf_file->CloseOnDisk();
472
473     //      delete hdf_dataset;
474     //      delete hdf_group; ----> SEGFAULT !!!
475     //      delete hdf_file; ----> SEGFAULT !!!
476   }
477   catch (HDFexception)
478   {
479     SALOME::ExceptionStruct es;
480     es.type = SALOME::INTERNAL_ERROR;
481     std::string text = "!!!! HDFexception";
482     es.text = CORBA::string_dup(text.c_str());
483     throw SALOME::SALOME_Exception(es);
484   }
485 }
486
487 //=============================================================================
488 /*! 
489  *  CORBA method
490  * \see Engines::Salome_file::setLocalFile
491  */
492 //=============================================================================
493 void 
494 Salome_file_i::setLocalFile(const char* comp_file_name)
495 {
496   std::string file_name("");
497   std::string path("");
498   std::string type("local");
499   std::string source_file_name("");
500   std::string status("not_ok");
501
502   std::string cp_file_name(comp_file_name);
503   std::size_t index = cp_file_name.rfind("/");
504   if (index != -1)
505   {
506     file_name = cp_file_name.substr(index+1);
507     path =  cp_file_name.substr(0,index+1);
508   }
509   else
510   {
511     file_name = comp_file_name;    
512     path = getcwd(NULL, _path_max);;
513   }
514
515   // Test if this file is already added
516   _t_fileManaged::iterator it = _fileManaged.find(file_name);
517   if (it != _fileManaged.end()) 
518   {
519     SALOME::ExceptionStruct es;
520     es.type = SALOME::INTERNAL_ERROR;
521     std::string text = "file already added";
522     es.text = CORBA::string_dup(text.c_str());
523     throw SALOME::SALOME_Exception(es);
524   }
525
526   // Test if the file is ok
527   if(fopen(comp_file_name,"rb") != NULL)
528     status = "ok";
529
530   // Adding file with its information
531   Engines::file infos;
532   infos.file_name = CORBA::string_dup(file_name.c_str());
533   infos.path = CORBA::string_dup(path.c_str());
534   infos.type = CORBA::string_dup(type.c_str());
535   infos.source_file_name = CORBA::string_dup(source_file_name.c_str());
536   infos.status = CORBA::string_dup(status.c_str());
537   // Infos for parallel extensions...
538   infos.node = 0;
539   infos.container = Engines::Container::_duplicate(_container);
540
541   _fileManaged[file_name] = infos;
542
543   // Update Salome_file state
544   _state.number_of_files++;
545   if (status != "ok")
546     _state.files_ok = false;
547 }
548
549 //=============================================================================
550 /*! 
551  *  CORBA method
552  * \see Engines::Salome_file::setDistributedFile
553  */
554 //=============================================================================
555 void 
556 Salome_file_i::setDistributedFile(const char* comp_file_name)
557 {
558   std::string file_name("");
559   std::string path("");
560   std::string type("distributed");
561   std::string source_file_name("");
562   std::string status("not_ok");
563
564   std::string cp_file_name(comp_file_name);
565   std::size_t index = cp_file_name.rfind("/");
566   if (index != -1)
567   {
568     file_name = cp_file_name.substr(index+1);
569     path =  cp_file_name.substr(0,index+1);
570   }
571   else
572   {
573     file_name = comp_file_name;
574     path = getcwd(NULL, _path_max);;
575   }
576
577   // Test if this file is already added
578   _t_fileManaged::iterator it = _fileManaged.find(file_name);
579   if (it != _fileManaged.end()) 
580   {
581     SALOME::ExceptionStruct es;
582     es.type = SALOME::INTERNAL_ERROR;
583     std::string text = "file already added";
584     es.text = CORBA::string_dup(text.c_str());
585     throw SALOME::SALOME_Exception(es);
586   }
587
588   // Adding file with its information
589   Engines::file infos;
590   infos.file_name = CORBA::string_dup(file_name.c_str());
591   infos.path = CORBA::string_dup(path.c_str());
592   infos.type = CORBA::string_dup(type.c_str());
593   infos.source_file_name = CORBA::string_dup(source_file_name.c_str());
594   infos.status = CORBA::string_dup(status.c_str());
595   // Infos for parallel extensions...
596   infos.node = 0;
597   infos.container = Engines::Container::_duplicate(_container);
598
599   _fileManaged[file_name] = infos;
600
601   if(!CORBA::is_nil(_default_source_Salome_file)) 
602   {
603     _fileDistributedSource[file_name] = 
604       Engines::Salome_file::_duplicate(_default_source_Salome_file);
605   }
606
607   // Update Salome_file state
608   _state.number_of_files++;
609   _state.files_ok = false;
610 }
611
612 //=============================================================================
613 /*! 
614  *  CORBA method
615  * \see Engines::Salome_file::connect
616  */
617 //=============================================================================
618 void
619 Salome_file_i::connect(Engines::Salome_file_ptr source_Salome_file) 
620 {
621   if(CORBA::is_nil(_default_source_Salome_file)) 
622   {
623     _default_source_Salome_file = Engines::Salome_file::_duplicate(source_Salome_file);
624     _t_fileManaged::iterator begin = _fileManaged.begin();
625     _t_fileManaged::iterator end = _fileManaged.end();
626     for(;begin!=end;begin++) {
627       // Get the name of the file
628       std::string file_name = begin->first;
629       _t_fileDistributedSource::iterator it = _fileDistributedSource.find(file_name);
630       if (it == _fileDistributedSource.end()) 
631       {
632         _fileDistributedSource[file_name] = Engines::Salome_file::_duplicate(source_Salome_file);
633       }
634     }
635   }
636   else
637   {
638     SALOME::ExceptionStruct es;
639     es.type = SALOME::INTERNAL_ERROR;
640     std::string text = "already connected to a default Salome_file";
641     es.text = CORBA::string_dup(text.c_str());
642     throw SALOME::SALOME_Exception(es);
643   }
644   // We can connect this Salome_file if there is only one file managed
645   // by the Salome_file
646   //std::string fname;
647   //if (_fileManaged.size() == 1) 
648   //{
649     // only one file managed 
650   //  _t_fileManaged::iterator it = _fileManaged.begin();
651   //  fname = it->first;
652   //  _fileDistributedSource[fname] = Engines::Salome_file::_duplicate(source_Salome_file);
653   //}
654   //else 
655   //{
656   //  SALOME::ExceptionStruct es;
657   //  es.type = SALOME::INTERNAL_ERROR;
658   //  std::string text = "cannot connect";
659    // es.text = CORBA::string_dup(text.c_str());
660    // throw SALOME::SALOME_Exception(es);
661   //}
662 }
663
664 //=============================================================================
665 /*! 
666  *  CORBA method
667  * \see Engines::Salome_file::connectDistributedFile
668  */
669 //=============================================================================
670 void
671 Salome_file_i::connectDistributedFile(const char * file_name,
672                                       Engines::Salome_file_ptr source_Salome_file) 
673 {
674   // Test if this file is added
675   _t_fileManaged::iterator it = _fileManaged.find(file_name);
676   if (it == _fileManaged.end()) 
677   {
678     SALOME::ExceptionStruct es;
679     es.type = SALOME::INTERNAL_ERROR;
680     std::string text = "file is not added";
681     es.text = CORBA::string_dup(text.c_str());
682     throw SALOME::SALOME_Exception(es);
683   }
684   else 
685   {
686     _fileDistributedSource[file_name] = Engines::Salome_file::_duplicate(source_Salome_file);
687   }
688 }
689
690 //=============================================================================
691 /*! 
692  *  CORBA method
693  * \see Engines::Salome_file::setDistributedSourceFile
694  */
695 //=============================================================================
696 void 
697 Salome_file_i::setDistributedSourceFile(const char* file_name,
698                                         const char * source_file_name)
699 {
700   std::string fname(file_name);
701
702   // Test if this file is added
703   _t_fileManaged::iterator it = _fileManaged.find(fname);
704   if (it == _fileManaged.end()) 
705   {
706     SALOME::ExceptionStruct es;
707     es.type = SALOME::INTERNAL_ERROR;
708     std::string text = "file is not added";
709     es.text = CORBA::string_dup(text.c_str());
710     throw SALOME::SALOME_Exception(es);
711   }
712   else 
713   {
714     _fileManaged[fname].source_file_name = CORBA::string_dup(source_file_name);
715   }
716 }
717
718 //=============================================================================
719 /*! 
720  *  CORBA method
721  * \see Engines::Salome_file::recvFiles
722  */
723 //=============================================================================
724 void 
725 Salome_file_i::recvFiles() {
726   
727   std::string files_not_ok("");
728
729   _t_fileManaged::iterator begin = _fileManaged.begin();
730   _t_fileManaged::iterator end = _fileManaged.end();
731   for(;begin!=end;begin++) 
732   {
733     bool result = true;
734     Engines::file file_infos = begin->second;
735     // Test if the file is local or distributed
736     if (std::string(file_infos.type.in()) == "local")
737     {
738       if (std::string(file_infos.status.in()) == "not_ok")
739         result = checkLocalFile(file_infos.file_name.in());
740     }
741     else
742     {
743       if (std::string(file_infos.status.in()) == "not_ok")
744         result = getDistributedFile(file_infos.file_name.in());
745     }
746     // if the result is false
747     // we add this file to files_not_ok
748     if (!result) 
749     {
750       files_not_ok.append(" ");
751       files_not_ok.append(file_infos.file_name.in());
752     }
753   }
754
755   if (files_not_ok != "")
756   {
757     SALOME::ExceptionStruct es;
758     es.type = SALOME::INTERNAL_ERROR;
759     std::string text = "files not ready : " + files_not_ok;
760     es.text = CORBA::string_dup(text.c_str());
761     throw SALOME::SALOME_Exception(es);
762   }
763   else
764   {
765     // We change the state of the Salome_file
766     _state.files_ok = true;
767   }
768 }
769
770 //=============================================================================
771 /*! 
772  *  local C++ method : This method is used by revFiles to check if a local 
773  *  managed file is ok.
774  *  \param  fileName name of the file
775  */
776 //=============================================================================
777 bool
778 Salome_file_i::checkLocalFile(std::string file_name)
779 {
780   bool result = true;
781
782   std::string comp_file_name(_fileManaged[file_name].path.in());
783   comp_file_name.append("/");
784   comp_file_name.append(_fileManaged[file_name].file_name.in());
785   if(fopen(comp_file_name.c_str(),"rb") == NULL)
786   {
787     INFOS("file " << comp_file_name << " cannot be open for reading");
788     _fileManaged[file_name].status = CORBA::string_dup("not_ok");
789     result = false;
790   }
791
792   if (result)
793   {
794     _fileManaged[file_name].status = CORBA::string_dup("ok");
795   }
796   return result;
797 }
798
799 //=============================================================================
800 /*! 
801  *  local C++ method : this method is used by recvFiles to get a 
802  *  distributed file from is distributed source.
803  *  If there is no source_file_name for the file, it tries to get
804  *  the file from the source. In this case, the source distributed file has to managed
805  *  only one file to be able to the send the file.
806  *
807  *  \param  fileName name of the file
808  */
809 //=============================================================================
810 bool
811 Salome_file_i::getDistributedFile(std::string file_name)
812 {
813   bool result = true;
814   const char * source_file_name = _fileManaged[file_name].source_file_name.in();
815   int fileId;
816   FILE* fp;
817   std::string comp_file_name(_fileManaged[file_name].path.in());
818   comp_file_name.append("/");
819   comp_file_name.append(_fileManaged[file_name].file_name.in());
820
821   // Test if the process can write on disk
822   if ((fp = fopen(comp_file_name.c_str(),"wb")) == NULL)
823   {
824     INFOS("file " << comp_file_name << " cannot be open for writing");
825     _fileManaged[file_name].status = CORBA::string_dup("not_ok");
826     result = false;
827     return result;
828   }
829
830   try 
831   {
832     fileId = _fileDistributedSource[file_name]->open(source_file_name);
833   }
834   catch (...) 
835   {
836     _fileManaged[file_name].status = CORBA::string_dup("not_ok");
837     fclose(fp);
838     result = false;
839     return result;
840   }
841
842   if (fileId > 0)
843   {
844     Engines::fileBlock* aBlock;
845     int toFollow = 1;
846     int ctr=0;
847     MESSAGE("begin of transfer of " << comp_file_name);
848     while (toFollow)
849     {
850       ctr++;
851       aBlock = _fileDistributedSource[file_name]->getBlock(fileId);
852       toFollow = aBlock->length();
853       CORBA::Octet *buf = aBlock->get_buffer();
854 #if defined(_DEBUG_) || defined(_DEBUG)
855       int nbWri = fwrite(buf, sizeof(CORBA::Octet), toFollow, fp);
856       ASSERT(nbWri == toFollow);
857 #else
858       fwrite(buf, sizeof(CORBA::Octet), toFollow, fp);
859 #endif
860       delete aBlock;
861     }
862     fclose(fp);
863     MESSAGE("end of transfer of " << comp_file_name);
864     _fileDistributedSource[file_name]->close(fileId);
865   }
866   else
867   {
868     INFOS("open reference file for copy impossible");
869     result = false;
870     fclose(fp);
871     _fileManaged[file_name].status = CORBA::string_dup("not_ok");
872     return result;
873   }
874
875   _fileManaged[file_name].status = CORBA::string_dup("ok");
876   return result;
877 }
878
879 //=============================================================================
880 /*! 
881  *  CORBA method
882  * \see Engines::Salome_file::removeFile
883  */
884 //=============================================================================
885 void 
886 Salome_file_i::removeFile(const char* file_name) 
887 {
888   MESSAGE("Salome_file_i::removeFile : NOT YET IMPLEMENTED");
889 }
890     
891 //=============================================================================
892 /*! 
893  *  CORBA method
894  * \see Engines::Salome_file::removeFiles
895  */
896 //=============================================================================
897 void 
898 Salome_file_i::removeFiles() {
899   MESSAGE("Salome_file_i::removeFiles : NOT YET IMPLEMENTED");
900 }
901
902 //=============================================================================
903 /*! 
904  *  CORBA method
905  * \see Engines::Salome_file::getFilesInfos
906  */
907 //=============================================================================
908 Engines::files* 
909 Salome_file_i::getFilesInfos() {
910
911   Engines::files * infos = new Engines::files();
912   infos->length(_fileManaged.size());
913
914   _t_fileManaged::iterator begin = _fileManaged.begin();
915   _t_fileManaged::iterator end = _fileManaged.end();
916   int i = 0;
917   for(;begin!=end;begin++) {
918     (*infos)[i] = *(new Engines::file(begin->second));
919     i++;
920   }
921   return infos;
922 }
923
924 //=============================================================================
925 /*! 
926  *  CORBA method
927  * \see Engines::Salome_file::getFileInfos
928  */
929 //=============================================================================
930 Engines::file* 
931 Salome_file_i::getFileInfos(const char* file_name) {
932
933   std::string fname(file_name);
934
935   // Test if this file is managed
936   _t_fileManaged::iterator it = _fileManaged.find(fname);
937   if (it == _fileManaged.end()) 
938   {
939     SALOME::ExceptionStruct es;
940     es.type = SALOME::INTERNAL_ERROR;
941     es.text = "file is not managed";
942     throw SALOME::SALOME_Exception(es);
943   }
944
945   Engines::file * infos = new Engines::file(_fileManaged[fname]);
946   return infos;
947 }
948
949 //=============================================================================
950 /*! 
951  *  CORBA method
952  * \see Engines::Salome_file::getSalome_fileState
953  */
954 //=============================================================================
955 Engines::SfState* 
956 Salome_file_i::getSalome_fileState() 
957 {
958   return new Engines::SfState(_state);
959 }
960
961 //=============================================================================
962 /*! 
963  *  CORBA method: try to open the file given. If the file is readable, return
964  *  a positive integer else return 0;
965  *  \param  fileName file name to be transferred
966  *  \return fileId = positive integer > 0 if open OK.
967  */
968 //=============================================================================
969
970 CORBA::Long 
971 Salome_file_i::open(const char* file_name)
972 {
973   int aKey = 0;
974
975   std::string fname(file_name);
976   if (fname == "") {
977     // We enter in the simple case where the user
978     // has not used setDistributedSourceFile.
979     // In this case we try to see if the Salome_file
980     if (_fileManaged.size() == 1) 
981     {
982       // only one file managed 
983       _t_fileManaged::iterator it = _fileManaged.begin();
984       fname = it->first;
985     }
986     else
987     {
988       // we can't choose the file so :
989       return aKey;
990     }
991   }
992
993   _t_fileManaged::iterator it = _fileManaged.find(fname);
994   if (it == _fileManaged.end())
995   {
996     return aKey;
997   }
998   
999   std::string comp_file_name(_fileManaged[fname].path.in());
1000   comp_file_name.append("/");
1001   comp_file_name.append(fname);
1002   MESSAGE("Salome_file_i::open " << comp_file_name);
1003   FILE* fp;
1004   if ((fp = fopen(comp_file_name.c_str(),"rb")) == NULL)
1005     {
1006       INFOS("file " << comp_file_name << " is not readable");
1007       return aKey;
1008     }
1009
1010   aKey = ++_fileId;
1011   _fileAccess[aKey] = fp;
1012   return aKey;
1013 }
1014
1015 //=============================================================================
1016 /*! 
1017  *  CORBA method: close the file associated to the fileId given at open.
1018  *  \param fileId got in return from open method
1019  */
1020 //=============================================================================
1021
1022 void 
1023 Salome_file_i::close(CORBA::Long fileId)
1024 {
1025   MESSAGE("Salome_file_i::close");
1026   FILE* fp;
1027   if (!(fp = _fileAccess[fileId]) )
1028     {
1029       INFOS(" no FILE structure associated to fileId " << fileId);
1030     }
1031   else fclose(fp);
1032 }
1033
1034 //=============================================================================
1035 /*! 
1036  *  CORBA method: get a block of data from the file associated to the fileId
1037  *  given at open.
1038  *  \param fileId got in return from open method
1039  *  \return an octet sequence. Last one is empty.
1040  */
1041 //=============================================================================
1042
1043 #define FILEBLOCK_SIZE 256*1024
1044
1045 Engines::fileBlock* 
1046 Salome_file_i::getBlock(CORBA::Long fileId)
1047 {
1048   Engines::fileBlock* aBlock = new Engines::fileBlock;
1049
1050   FILE* fp;
1051   if (! (fp = _fileAccess[fileId]) )
1052   {
1053     INFOS(" no FILE structure associated to fileId " <<fileId);
1054     return aBlock;
1055   }
1056
1057   // use replace member function for sequence to avoid copy
1058   // see Advanced CORBA Programming with C++ pp 187-194
1059   CORBA::Octet *buf;
1060   buf = Engines::fileBlock::allocbuf(FILEBLOCK_SIZE);
1061   int nbRed = fread(buf, sizeof(CORBA::Octet), FILEBLOCK_SIZE, fp);
1062   aBlock->replace(nbRed, nbRed, buf, 1); // 1 means give ownership
1063   return aBlock;
1064 }
1065
1066 void 
1067 Salome_file_i::setContainer(Engines::Container_ptr container)
1068 {
1069   _container = Engines::Container::_duplicate(container);
1070
1071   // Update All the files
1072   _t_fileManaged::iterator begin = _fileManaged.begin();
1073   _t_fileManaged::iterator end = _fileManaged.end();
1074   for(;begin!=end;begin++) {
1075     begin->second.container = Engines::Container::_duplicate(container);
1076   }
1077 }
1078