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