idl/SALOME_Component.idl

   1 // Copyright (C) 2007-2024  CEA, EDF, 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 //  File   : SALOME_Component.idl
  24 //  Author : Paul RASCLE, EDF
  25
  26 #ifndef _SALOME_COMPONENT_IDL_
  27 #define _SALOME_COMPONENT_IDL_
  28
  29 #include "SALOME_GenericObj.idl"
  30 #include "SALOMEDS.idl"
  31 #include "SALOME_Exception.idl"
  32 #include "SALOME_PyNode.idl"
  33 #include "SALOME_Embedded_NamingService.idl"
  34 #include "SALOME_Comm.idl"
  35
  36 /*! \file SALOME_Component.idl \brief interfaces for EngineComponent and Container
  37 */
  38
  39 /*! \brief
  40 This is a package of interfaces used for connecting new components to %SALOME
  41 application. It also contains a set of interfaces used for management of %FIELDS
  42 component in %SALOME application.
  43 */
  44 module Engines
  45 {
  46   /*!
  47     A byte stream which is used for binary data transfer between different
  48     components
  49   */
  50   typedef sequence<octet> TMPFile;
  51
  52   //!  General Key Value Structure to set or get properties, for component
  53   struct KeyValuePair
  54   {
  55     string key;
  56     any value;
  57   };
  58
  59   //!  Structure data type to hold reference on data
  60   struct dataref
  61   {
  62     string ref;
  63   };
  64
  65   typedef sequence<KeyValuePair> FieldsDict;
  66   typedef sequence<double> vectorOfDouble;
  67   typedef sequence<string> vectorOfString;
  68   typedef sequence<vectorOfString> vectorOfVectorOfString;
  69
  70   interface EngineComponent ;
  71   interface fileRef ;
  72   interface fileTransfer ;
  73   interface Salome_file;
  74
  75   /*! \brief Interface of the %Container.
  76   This interface defines the process of loading and registration
  77   of new components in %SALOME application
  78   */
  79
  80   interface Container
  81   {
  82
  83     void override_environment( in FieldsDict env );
  84
  85     void override_environment_python( in FieldsDict env );
  86
  87     FieldsDict get_os_environment();
  88
  89     void set_big_obj_on_disk_threshold(in long thresholdInByte);
  90
  91     void set_big_obj_on_disk_directory(in string directory);
  92
  93     void set_directory_for_replay_files(in string directory);
  94
  95     void set_number_of_retry(in long nbRetry);
  96
  97     void set_current_directory(in string cwd);
  98
  99     void set_startup_code(in string codeAtStartUp);
 100
 101     string get_startup_code();
 102
 103     void addLogFileNameGroup(in vectorOfString groupOfLogFileNames);
 104
 105     vectorOfVectorOfString getAllLogFileNameGroups();
 106
 107     void execute_python_code( in string code ) raises(SALOME::SALOME_Exception);
 108
 109     /*! \brief Loads a new component class (dynamic library).
 110
 111       \param componentName like COMPONENT, (Python or C++ implementation)
 112                            try to make a Python import of COMPONENT,
 113                            then a lib open of libCOMPONENTEngine.so
 114       \param reason      in case of error (return false) a string explaining the error
 115       \return true if load successful or already done, false otherwise
 116     */
 117     boolean load_component_Library(in string componentName, out string reason);
 118
 119     //! Create a new servant instance of a component.
 120     /*!
 121       Component library must be loaded.
 122       \param componentName Name of the component which will be registered
 123                            in Registry and Name Service,
 124                          (instance number suffix added to the registered name)
 125       \return a loaded component
 126     */
 127     Engines::EngineComponent create_component_instance(in string componentName);
 128
 129     //! Create a new Python servant instance of a generic service.
 130         /*!
 131           This simply loads the service in the current container by importing the
 132           corresponding Python module.
 133           Warning: no internal registration is done, so it is up to the caller to
 134           manage the various instantiation.
 135           \param serviceName Name of the service
 136           \param reason  in case of error (return void string) a string explaining the error
 137           \return the IOR of the loaded service.
 138         */
 139     string create_python_service_instance(in string serviceName,
 140                                           out string reason);
 141
 142     //! Create a new servant instance of a component with environment variables specified.
 143     /*!
 144       Component library must be loaded.
 145       \param componentName Name of the component which will be registered
 146                            in Registry and Name Service,
 147                          (instance number suffix added to the registered name)
 148       \param env         a dict of env variables
 149       \param reason      in case of error (return nil) a string explaining the error
 150       \return a loaded component
 151     */
 152     Engines::EngineComponent create_component_instance_env(in string componentName,
 153                                                            in FieldsDict env,
 154                                                            out string reason);
 155     //! Find a servant instance of a component
 156     /*!
 157       \param registeredName  Name of the component in Registry or Name Service,
 158                              without instance suffix number
 159       \return the first instance found
 160     */
 161     EngineComponent find_component_instance(in string registeredName);
 162
 163     //! Find a servant instance of a component, or create a new one.
 164     /*!
 165       Loads the component library if needed.
 166       Only applicable to multiStudy components.
 167       \param nameToRegister Name of the component which will be registered
 168                             in Registry (or Name Service)
 169       \param componentName  Name of the constructed library of the %component
 170                             (not used any more, give empty string)
 171       \return a loaded component
 172     */
 173     EngineComponent load_impl(in string nameToRegister,
 174                               in string componentName);
 175
 176     //! Remove the component servant, and deletes all related objects
 177     /*!
 178       \param component_i     Component to be removed
 179     */
 180     void remove_impl(in EngineComponent component_i);
 181
 182     //! In case of SSL mode Returns entry to Embedded NS
 183     EmbeddedNamingService get_embedded_NS_if_ssl();
 184
 185     boolean is_SSL_mode();
 186
 187     //!  Unload component libraries from the container.
 188     void finalize_removal() ;
 189
 190     //!  Determines whether the server has been loaded or not.
 191     void ping();
 192
 193     //!  Name of the %container
 194     readonly attribute string name ;
 195
 196     //!  working directory of the %container
 197     readonly attribute string workingdir ;
 198
 199     //!  name of the %container log file (this has been set by the launcher)
 200     attribute string logfilename ;
 201
 202     //!  name of the %container log file
 203     attribute string locallogfilename ;
 204
 205     //! interval of time between two measures of CPU/time process container
 206     attribute long monitoringtimeresms;
 207
 208     void verbosity(out boolean activated, out string level);
 209
 210     void setVerbosity(in boolean activated, in string level);
 211
 212     //!  Shutdown the Container process. Shutdown is not immediate. It waits for all remaining invokation completion.
 213     void Shutdown();
 214
 215     //!  Shutdown the Container process. Shutdown is immediate for this method.
 216     void ShutdownNow();
 217
 218     //!  Returns the hostname of the container
 219     string getHostName();
 220
 221     //!  Returns the PID of the container
 222     long getPID();
 223
 224     //! Kill the container
 225     /*!
 226       Returns True if the %container has been killed.
 227       Kept for Superv compilation but can't work, unless oneway...
 228       TO REMOVE !
 229     */
 230     boolean Kill_impl() ;
 231
 232     //! Create a fileRef
 233     /*!
 234       returns a fileRef object if origFileName exists and is readable
 235       else returns null object. Only one fileRef is created for a given
 236       file name, so, several calls with the same file name returns the
 237       same object.
 238     */
 239     fileRef createFileRef(in string origFileName);
 240
 241     //! Create a Salome_file
 242     /*!
 243       returns a Salome_file object if origFileName exists and is readable
 244       else returns null object.
 245
 246       \param origFileName name of the file to be managed (can contain the path).
 247
 248       \return Salome_file CORBA reference.
 249     */
 250     Salome_file createSalome_file(in string origFileName);
 251
 252     //! Create a fileTransfer
 253     /*!
 254       returns a fileTransfer object used to copy files from the container
 255       machine to the clients machines. Only one fileTransfer instance is
 256       created in a container.
 257     */
 258     fileTransfer getFileTransfer();
 259
 260     //! Copy a file from a remote host (container) to a local file
 261     /*!
 262       \param contai the remote container
 263       \param remoteFile the file on the remote host to copy
 264       \param localFile the local file to create by copy
 265      */
 266     void copyFile(in Container contai, in string remoteFile, in string localFile);
 267
 268     //! Create a PyNode in the container
 269     /*!
 270       \param nodeName the name of the PyNode
 271       \param code python code as text to load in the node
 272      */
 273     PyNode createPyNode(in string nodeName, in string code)  raises(SALOME::SALOME_Exception);
 274
 275     //! Retrieves the last created PyNode instance with createPyNode.
 276     PyNode getDefaultPyNode(in string nodeName);
 277
 278     //! Create a PyScriptNode in the container
 279     /*!
 280       \param nodeName the name of the PyScriptNode
 281       \param code python code as text to load in the node
 282      */
 283     PyScriptNode createPyScriptNode(in string nodeName, in string code)  raises(SALOME::SALOME_Exception);
 284
 285     void removePyScriptNode(in string nodeName) raises(SALOME::SALOME_Exception);
 286
 287     //! Retrieves the last created PyScriptNode instance with createPyScriptNode.
 288     PyScriptNode getDefaultPyScriptNode(in string nodeName);
 289
 290     //! This method remove all refs of PyScriptNode servant objects stored in server.
 291     /*!
 292      * Previous scripts created on container may have been stored in a map. This method removes them. It then clean all the contexts dict attached to them.
 293      */
 294     void cleanAllPyScripts();
 295
 296     //! Return number of CPU cores in the calculation node.
 297     long getNumberOfCPUCores();
 298
 299     //! Return a load of each CPU core.
 300     vectorOfDouble loadOfCPUCores() raises(SALOME::SALOME_Exception);
 301
 302     //! Set custom script to calculate a load of each CPU core.
 303     /*!
 304       \param script Python script to execute
 305      */
 306     void setPyScriptForCPULoad(in string script);
 307
 308     //! Nullify custom script to calculate each CPU core's load.
 309     void resetScriptForCPULoad();
 310
 311     //! Get total physical memory of calculation node, in megabytes.
 312     long getTotalPhysicalMemory();
 313
 314     //! Get used physical memory of calculation node, in megabytes.
 315     long getTotalPhysicalMemoryInUse();
 316
 317     //! Obtain physical memory, used by the current process, in megabytes.
 318     long getTotalPhysicalMemoryInUseByMe();
 319   };
 320
 321   /*! \brief Interface of the %component.
 322   This interface is used for interaction between the %container and the
 323   %component and between the components inside the container.
 324   */
 325   interface EngineComponent
 326   {
 327     //!  The name of the instance of the %Component
 328     readonly attribute string instanceName ;
 329
 330     //!  The name of the interface of the %Component
 331     readonly attribute string interfaceName ;
 332
 333     //!  Determines whether the server has already been loaded or not.
 334     void ping();
 335
 336     boolean isSSLMode() raises(SALOME::SALOME_Exception);
 337     //! Remove component instance from container
 338     /*!
 339       Deactivates the %Component.
 340       -- TO BE USED BY CONTAINER ONLY (Container housekeeping) --
 341       use remove_impl from Container instead !
 342     */
 343     void destroy() ;
 344
 345     //!  Returns the container that the %Component refers to.
 346     Container GetContainerRef() ;
 347
 348     //! Set component instance properties
 349     /*!
 350       Gives a sequence of (key=string,value=any) to the component.
 351       Base class component stores the sequence in a map.
 352       The map is cleared before.
 353       This map is for use by derived classes.
 354     */
 355     void setProperties(in FieldsDict dico);
 356
 357     //! Get component instance properties
 358     /*!
 359       returns a previously stored map (key=string,value=any) as a sequence.
 360       See setProperties(in FieldsDict dico).
 361     */
 362     FieldsDict getProperties();
 363
 364     //! Set an option value
 365     /*!
 366       This method is to set an option specific to a certain EngineComponent.
 367     */
 368     void SetOption(in string optionName, in string value);
 369
 370     //! Return an option value
 371     /*!
 372       This method is to get value of an option specific to a certain EngineComponent.
 373     */
 374     string GetOption(in string optionName);
 375
 376     //! Set name of a node in a graph (for %SUPERVISOR use)
 377     /*!
 378       This method is used by the %SUPERVISOR component. It sets the names of
 379       the graph and of the node.
 380       \param aGraphName Name of graph
 381       \param aNodeName  Name of node
 382     */
 383     void Names( in string aGraphName , in string aNodeName ) ;
 384
 385     //! Kill the component (if you can)
 386     /*!
 387       Returns True if the %Component has been killed.
 388     */
 389     boolean Kill_impl() ;
 390
 391     //! Stop the component (if you can)
 392     /*!
 393       Returns True if the activity of the %Component has been stopped.
 394       (It's action can't be resumed)
 395     */
 396     boolean Stop_impl() ;
 397
 398     //! Suspend the component
 399     /*!
 400       Returns True if the activity of the %Component has been suspended.
 401       (It's action can be resumed)
 402     */
 403     boolean Suspend_impl() ;
 404
 405     //! Resume the component
 406     /*!
 407       Returns True if the activity of the %Component has been resumed.
 408     */
 409     boolean Resume_impl() ;
 410
 411     //! Get the cpu used
 412     /*!
 413       Returns the Cpu used
 414     */
 415     long CpuUsed_impl() ;
 416
 417     //! Get a python dump
 418     /*!
 419       Returns a python script, which is being played back reproduces
 420       the data model of component
 421     */
 422     TMPFile DumpPython(in boolean isPublished,
 423                        in boolean isMultiFile,
 424                        out boolean isValidScript);
 425
 426
 427     //! Returns a CORBA Ref of a input Salome_file managed by a service.
 428     /*!
 429
 430       \param service_name service's name.
 431       \param file_name name of the requested file.
 432
 433       \return CORBA Ref of the requested file.
 434
 435       \exception contains information of what if the component cannot
 436       sends the file's reference.
 437     */
 438     Engines::Salome_file getInputFileToService(in string service_name,
 439                                                in string Salome_file_name) raises(SALOME::SALOME_Exception);
 440
 441     //! Check service input files (transfer them if needed)
 442     /*!
 443       This method is used before the activation of the service. It calls
 444       recvFiles() on all the input Salome_file files of the service.
 445
 446       Before each recvFiles(), it uses the callback method named configureSalome_file.
 447       This method allows the user to configure the files managed by the Salome_file.
 448
 449       By default, there is no files managed when a Salome_file is created,
 450       but the supervisor set some files managed by the Salome_file from the information contained
 451       into the schema file.
 452
 453       \param service_name service's name.
 454
 455       \exception contains information about files that are not in a good state.
 456     */
 457     void checkInputFilesToService(in string service_name)           raises(SALOME::SALOME_Exception);
 458
 459     //!  This method adds a input Salome_file to a service of the component.
 460     /*!
 461
 462       \param service_name service's name.
 463       \param Salome_file_name name of the Salome_file
 464
 465       \return a reference of the Salome_file
 466
 467       \exception raises an exception if there is already
 468       a Salome_file with this name for the service.
 469     */
 470     Engines::Salome_file setInputFileToService(in string service_name,
 471                                                in string Salome_file_name)   raises(SALOME::SALOME_Exception);
 472
 473     //!  Returns a CORBA Ref of a output Salome_file managed by a service.
 474     /*!
 475
 476       \param service_name service's name.
 477       \param file_name name of the requested file.
 478
 479       \return CORBA Ref of the requested file.
 480
 481       \exception contains information of what if the component cannot
 482       sends the file's reference.
 483     */
 484     Engines::Salome_file getOutputFileToService(in string service_name,
 485                                                 in string Salome_file_name) raises(SALOME::SALOME_Exception);
 486
 487     //! Check service output files (transfer them if needed)
 488     /*!
 489       This method is used at the end of the service. It calls
 490       recvFiles() on all the output Salome_file files of the service.
 491
 492       Before each recvFiles(), it uses the callback method named configureSalome_file.
 493       This method allows the user to configure the files managed by the Salome_file.
 494
 495       By default, there is no files managed when a Salome_file is created,
 496       but the supervisor set some files managed by the Salome_file from the information contained
 497       into the schema file.
 498
 499       \param service_name service's name.
 500
 501       \exception contains information about files that are not in a good state.
 502     */
 503     void checkOutputFilesToService(in string service_name)        raises(SALOME::SALOME_Exception);
 504
 505     //!  This method adds an output Salome_file to a service of the component.
 506     /*!
 507
 508       \param service_name service's name.
 509       \param Salome_file_name name of the Salome_file
 510
 511       \return a reference of the Salome_file
 512
 513       \exception raises an exception if there is already
 514       a Salome_file with this name for the service.
 515     */
 516     Engines::Salome_file setOutputFileToService(in string service_name,
 517                                                 in string Salome_file_name)  raises(SALOME::SALOME_Exception);
 518
 519     //! Indicate if the component instance provides custom information about its objects.
 520     /*!
 521       Returns true if the component provides custom information about its objects, false otherwise.
 522       Should be redefined in the certain component to return true in case of this
 523       component provides such information.
 524     */
 525     boolean hasObjectInfo();
 526
 527     //! Get custom information about the given object.
 528     /*!
 529       This method is used to get the custom information about the given object.
 530       Should be redefined in the certain component in case of this
 531       component provides such information.
 532       It is worth using this method only if hasObjectInfo() method returns true.
 533
 534       \param entry object's entry.
 535
 536       \return an information about the given object.
 537     */
 538     string getObjectInfo(in string entry);
 539
 540     //! Get version of the component
 541     /*!
 542       This method is supposed to be implemented in all derived classes; default implementation
 543       returns "unknown" string that means that no version information about the component is available.
 544       \note The version of the component is stored to the study, as a part of general persistence
 545       mechanism; once stored, version information in the study cannot be changed.
 546
 547       \return string containing component's version, e.g. "1.0"
 548     */
 549     string getVersion();
 550   };
 551
 552   /*!
 553     \brief Base interface of the %component that supports exporting data.
 554   */
 555   interface ImportableComponent
 556   {
 557     /*! \brief Get a list of supported formats */
 558     SALOME::StringSeq GetImportableFormats();
 559     boolean           ImportDataAs(in string format, in SALOME::GenericObj exporter);
 560   };
 561
 562   //!  A block of binary data used for file transfer. The maximum size of the block is defined on server side.
 563   typedef sequence<octet> fileBlock;
 564
 565   /*! \brief Interface of fileTransfer.
 566      The fileTransfer and fileRef interfaces provide a file transfer service
 567      between different computers.
 568   */
 569   interface fileTransfer : SALOME::GenericObj
 570   {
 571     //! Open the file transfer
 572     /*!
 573       open method returns a key (fileId) that identifies the structure
 574       (ex: C FILE), associated to the original file on the server.
 575       The structure is created by a container for transfer of files availables
 576       on the computer which runs the container.
 577       Each open gives a unique fileId, to allow concurrent reads of the same
 578       File.
 579     */
 580     long open(in string fileName);
 581     //! Open the file transfer in write mode for file fileName
 582     /*!
 583       \param fileName the file to copy into with putBlock
 584       \return the id to use with putBlock
 585     */
 586     long openW(in string fileName);
 587
 588     //! Close the file transfer
 589     /*!
 590     when the file transfer is finished, close method releases structures
 591     created by open method, identified by fileId.
 592     */
 593     void close(in long fileId);
 594
 595     //! Get a file data block
 596     /*!
 597       Get successive blocks of octets from the original file.
 598       The last block is empty, and identifies the end of file.
 599     */
 600     fileBlock getBlock(in long fileId);
 601
 602     //! Put a file data block
 603     /*!
 604        \param fileId identification of the file obtained by openW
 605        \param block a data block to copy into the file identified by fileId
 606     */
 607     void putBlock(in long fileId, in fileBlock block);
 608
 609   };
 610
 611   //!  A file managed by a Salome_file.
 612   struct file {
 613     //! file name
 614     string file_name;
 615     //! path name
 616     string path;
 617     string type;
 618     string source_file_name;
 619     //! status ("present" or "notpresent")
 620     string status;
 621     long   node;
 622     Engines::Container container;
 623   };
 624
 625   //!  A sequence of Engines::file.
 626   typedef sequence<Engines::file> files;
 627
 628
 629   //!  The state of a Salome_file.
 630   struct SfState {
 631     //! file name
 632     string  name;
 633     //! hdf5 file where the file can be saved
 634     string  hdf5_file_name;
 635     //! number of files managed
 636     long    number_of_files;
 637     //! information if all the files are received
 638     boolean files_ok;
 639
 640   };
 641
 642   /*! \brief Interface of a Salome_file managed
 643     This file is independent of a Salome module. It can managed one or more
 644     real files. It's useful for parallel files. Currently Salome_file cannot manage
 645     two files that have the same name but not the same path.
 646   */
 647   interface Salome_file : Engines::fileTransfer
 648   {
 649     //!  Load a Salome_file from a hdf5 file.
 650     /*!
 651
 652       \param hdf5_file name (with path) of the hdf5_file.
 653
 654       \exception contains information of errors if the loading doesn't succeed.
 655      */
 656     void load(in string hdf5_file)                            raises (SALOME::SALOME_Exception);
 657
 658     //!  Save a Salome_file into a hdf5_file.
 659     /*!
 660
 661       \param  hdf5_file name (with path) of the hdf5_file.
 662
 663       \exception contains information of errors if the save doesn't succeed.
 664
 665     */
 666     void save(in string hdf5_file)                            raises (SALOME::SALOME_Exception);
 667
 668     //!  Save a Salome_file into a hdf5_file.
 669     /*!
 670       All files that are managed are saved into the hdf5_file
 671
 672       \param  hdf5_file name (with path) of the hdf5_file.
 673
 674       \exception contains information of errors if the save doesn't succeed.
 675
 676     */
 677     void save_all(in string hdf5_file)                            raises (SALOME::SALOME_Exception);
 678
 679 /**************/
 680
 681     //!  Add a Local file to the Salome_file.
 682     /*!
 683
 684       \param file_name name of the file with the path.
 685
 686       \exception raised if the file is already added into the Salome_file.
 687     */
 688     void setLocalFile(in string comp_file_name) raises (SALOME::SALOME_Exception);
 689
 690     //!  Add a Distributed file to the Salome_file.
 691     /*!
 692
 693       \param comp_file_name name of the file with the path.
 694
 695       \exception raised if the file is already added into the Salome_file.
 696     */
 697     void setDistributedFile(in string comp_file_name) raises (SALOME::SALOME_Exception);
 698
 699     //!  Connect a Salome_file with another Salome_file.
 700     /*!
 701       It works only if the Salome_file managed only one file
 702
 703       \param source_Salome_file Salome_file that managed the distributed version of the file.
 704
 705       \exception raised if there is more or less than one file.
 706     */
 707     void connect(in Engines::Salome_file source_Salome_file) raises (SALOME::SALOME_Exception);
 708
 709     //!  Connect the managed file file_name to a Salome_file.
 710     /*!
 711
 712       \param file_name name of the file without the path.
 713       \param source_Salome_file Salome_file that managed the distributed version of the file.
 714
 715       \exception raised if the file doesn't exist.
 716     */
 717     void connectDistributedFile(in string file_name,
 718                                 in Engines::Salome_file source_Salome_file) raises (SALOME::SALOME_Exception);
 719
 720     //!  Connect the file_name with a Distributed file_name.
 721     /*!
 722
 723       \param file_name name of the file without the path.
 724       \param source_file_name It's the name of the file managed by the distributed source Salome_file.
 725
 726       \exception raised if the file doesn't exist.
 727     */
 728     void setDistributedSourceFile(in string file_name,
 729                                   in string source_file_name) raises (SALOME::SALOME_Exception);
 730
 731 /**************/
 732
 733     //! Get all the distributed files managed by the Salome_file and check all the local files.
 734     /*!
 735
 736       \exception raised if some of the files are not ok.
 737     */
 738     void recvFiles()                                            raises (SALOME::SALOME_Exception) ;
 739
 740 /**************/
 741
 742     //!  Remove a file of the Salome_file.
 743     /*!
 744
 745       \param file_name name of the file.
 746
 747       \exception raised if the file doesn't exist.
 748     */
 749     void removeFile(in string file_name)                    raises (SALOME::SALOME_Exception);
 750
 751     //!  Remove all the files of the Salome_file.
 752     void removeFiles();
 753
 754 /**************/
 755
 756     //! Get the list of the files managed by the Salome_file.
 757     /*!
 758       The list can be empty.
 759     */
 760     Engines::files getFilesInfos();
 761
 762     //! Get a file managed by the Salome_file.
 763     /*!
 764
 765       \param file_name the name of the file.
 766
 767       \return CORBA file reference.
 768
 769       \exception raised if the file doesn't exist.
 770     */
 771     Engines::file  getFileInfos(in string file_name) raises (SALOME::SALOME_Exception);
 772
 773     //!  Return the state of the Salome_file.
 774     Engines::SfState getSalome_fileState();
 775
 776
 777     //! Set the container where files are.
 778     /*!
 779
 780       \param container container CORBA's reference.
 781     */
 782     void setContainer(in Engines::Container container);
 783   };
 784
 785   /*! \brief Interface of fileRef.
 786      The fileTransfer and fileRef interfaces provide a file transfer service
 787      between different computers.
 788
 789      A fileRef object is associated to an original file (origFileName) on a
 790      machine (refMachine).
 791      It is created by a container (factoryServer) on refMachine,
 792      with createFileRef(in string origFileName) method.
 793      The fileRef object maintains a list of (machine,filename) for copies.
 794      If a copy exists on myMachine, getRef(myMachine) returns the file name
 795      of the copy on myMachine, else returns empty string.
 796      If there is no copy on myMachine, method getFileTransfer() from container
 797      factoryServer on refMachine provides a fileTransfer object dedicated to
 798      CORBA file copy.
 799      After the copy, addRef(myMachine, localFileNameOnMyMachine) registers
 800      the file name of the copy on myMachine.
 801   */
 802   interface fileRef
 803   {
 804     //! the original file
 805     readonly attribute string origFileName;
 806     //! the machine of the original file
 807     readonly attribute string refMachine;
 808
 809     Container getContainer();
 810
 811     boolean addRef(in string machine,
 812                    in string fileName);
 813
 814     string getRef(in string machine);
 815   };
 816 };
 817
 818 #endif