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