SALOME_Component.idl

Go to the documentation of this file.

// Copyright (C) 2007-2026  CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
//  File   : SALOME_Component.idl
//  Author : Paul RASCLE, EDF
 
#ifndef _SALOME_COMPONENT_IDL_
#define _SALOME_COMPONENT_IDL_
 
#include "SALOME_GenericObj.idl"
#include "SALOMEDS.idl"
#include "SALOME_Exception.idl"
#include "SALOME_PyNode.idl"
#include "SALOME_Embedded_NamingService.idl"
#include "SALOME_Comm.idl"
 
module Engines
{
  typedef sequence<octet> TMPFile;
 
  struct KeyValuePair
  {
    string key;
    any value;
  };
 
  struct dataref
  {
    string ref;
  };
 
  typedef sequence<KeyValuePair> FieldsDict;
  typedef sequence<double> vectorOfDouble;
  typedef sequence<string> vectorOfString;
  typedef sequence<vectorOfString> vectorOfVectorOfString;
 
  interface EngineComponent ;
  interface fileRef ;
  interface fileTransfer ;
  interface Salome_file;
 
  interface Container
  {
 
    void override_environment( in FieldsDict env );
 
    void override_environment_python( in FieldsDict env );
 
    FieldsDict get_os_environment();
 
    void set_big_obj_on_disk_threshold(in long thresholdInByte);
 
    void set_big_obj_on_disk_directory(in string directory);
 
    void set_directory_for_replay_files(in string directory);
    
    void set_number_of_retry(in long nbRetry);
    
    void set_timeout_before_retrying(in long timeInSecond);
 
    void set_current_directory(in string cwd);
 
    void set_startup_code(in string codeAtStartUp);
 
    string get_startup_code();
 
    void addLogFileNameGroup(in vectorOfString groupOfLogFileNames);
    
    vectorOfVectorOfString getAllLogFileNameGroups();
 
    void execute_python_code( in string code ) raises(SALOME::SALOME_Exception);
 
    boolean load_component_Library(in string componentName, out string reason);
 
 
    Engines::EngineComponent create_component_instance(in string componentName);
 
 
    string create_python_service_instance(in string serviceName,
                                          out string reason);
 
 
    Engines::EngineComponent create_component_instance_env(in string componentName,
                                                           in FieldsDict env,
                                                           out string reason);
 
    EngineComponent find_component_instance(in string registeredName);
 
 
    EngineComponent load_impl(in string nameToRegister,
                              in string componentName);
 
 
    void remove_impl(in EngineComponent component_i);
    
    EmbeddedNamingService get_embedded_NS_if_ssl();
    
    boolean is_SSL_mode();
 
    void finalize_removal() ;
 
    void ping();
 
    readonly attribute string name ;
 
    readonly attribute string workingdir ;
 
    attribute string logfilename ;
    
    attribute string locallogfilename ;
 
    attribute long monitoringtimeresms;
    
    void verbosity(out boolean activated, out string level);
 
    void setVerbosity(in boolean activated, in string level);
 
    void Shutdown();
 
    void ShutdownNow();
 
    string getHostName();
 
    long getPID();
 
 
    boolean Kill_impl() ;
 
 
    fileRef createFileRef(in string origFileName);
 
 
    Salome_file createSalome_file(in string origFileName);
 
 
    fileTransfer getFileTransfer();
 
 
    void copyFile(in Container contai, in string remoteFile, in string localFile);
 
 
    PyNode createPyNode(in string nodeName, in string code)  raises(SALOME::SALOME_Exception);
 
    PyNode getDefaultPyNode(in string nodeName);
 
 
    PyScriptNode createPyScriptNode(in string nodeName, in string code)  raises(SALOME::SALOME_Exception);
 
    void removePyScriptNode(in string nodeName) raises(SALOME::SALOME_Exception);
 
    PyScriptNode getDefaultPyScriptNode(in string nodeName);
 
 
    void cleanAllPyScripts();
 
    long getNumberOfCPUCores();
 
    vectorOfDouble loadOfCPUCores() raises(SALOME::SALOME_Exception);
 
 
    void setPyScriptForCPULoad(in string script);
 
    void resetScriptForCPULoad();
 
    long getTotalPhysicalMemory();
 
    long getTotalPhysicalMemoryInUse();
 
    long getTotalPhysicalMemoryInUseByMe();
  };
 
  interface EngineComponent
  {
    readonly attribute string instanceName ;
 
    readonly attribute string interfaceName ;
 
    void ping();
 
    boolean isSSLMode() raises(SALOME::SALOME_Exception);
 
    void destroy() ;
 
    Container GetContainerRef() ;
 
 
    void setProperties(in FieldsDict dico);
 
 
    FieldsDict getProperties();
 
 
    void SetOption(in string optionName, in string value);
 
 
    string GetOption(in string optionName);
 
 
    void Names( in string aGraphName , in string aNodeName ) ;
 
 
    boolean Kill_impl() ;
 
 
    boolean Stop_impl() ;
 
 
    boolean Suspend_impl() ;
 
 
    boolean Resume_impl() ;
 
 
    long CpuUsed_impl() ;
 
 
    TMPFile DumpPython(in boolean isPublished,
                       in boolean isMultiFile,
                       out boolean isValidScript);
 
 
 
    Engines::Salome_file getInputFileToService(in string service_name,
                                               in string Salome_file_name) raises(SALOME::SALOME_Exception);
 
 
    void checkInputFilesToService(in string service_name)           raises(SALOME::SALOME_Exception);
 
 
    Engines::Salome_file setInputFileToService(in string service_name,
                                               in string Salome_file_name)   raises(SALOME::SALOME_Exception);
 
 
    Engines::Salome_file getOutputFileToService(in string service_name,
                                                in string Salome_file_name) raises(SALOME::SALOME_Exception);
 
 
    void checkOutputFilesToService(in string service_name)        raises(SALOME::SALOME_Exception);
 
 
    Engines::Salome_file setOutputFileToService(in string service_name,
                                                in string Salome_file_name)  raises(SALOME::SALOME_Exception);
 
 
    boolean hasObjectInfo();
 
 
    string getObjectInfo(in string entry);
 
 
    string getVersion();
  };
 
  interface ImportableComponent
  {
    SALOME::StringSeq GetImportableFormats();
    boolean           ImportDataAs(in string format, in SALOME::GenericObj exporter);
  };
 
  typedef sequence<octet> fileBlock;
 
  interface fileTransfer : SALOME::GenericObj
  {
 
    long open(in string fileName);
 
    long openW(in string fileName);
 
 
    void close(in long fileId);
 
 
    fileBlock getBlock(in long fileId);
 
 
    void putBlock(in long fileId, in fileBlock block);
 
  };
 
  struct file {
    string file_name;
    string path;
    string type;
    string source_file_name;
    string status;
    long   node;
    Engines::Container container;
  };
 
  typedef sequence<Engines::file> files;
 
 
  struct SfState {
    string  name;
    string  hdf5_file_name;
    long    number_of_files;
    boolean files_ok;
 
  };
 
  interface Salome_file : Engines::fileTransfer
  {
 
    void load(in string hdf5_file)                            raises (SALOME::SALOME_Exception);
 
 
    void save(in string hdf5_file)                            raises (SALOME::SALOME_Exception);
 
 
    void save_all(in string hdf5_file)                            raises (SALOME::SALOME_Exception);
 
/**************/
 
 
    void setLocalFile(in string comp_file_name) raises (SALOME::SALOME_Exception);
 
 
    void setDistributedFile(in string comp_file_name) raises (SALOME::SALOME_Exception);
 
 
    void connect(in Engines::Salome_file source_Salome_file) raises (SALOME::SALOME_Exception);
 
 
    void connectDistributedFile(in string file_name,
                                in Engines::Salome_file source_Salome_file) raises (SALOME::SALOME_Exception);
 
 
    void setDistributedSourceFile(in string file_name,
                                  in string source_file_name) raises (SALOME::SALOME_Exception);
 
/**************/
 
 
    void recvFiles()                                            raises (SALOME::SALOME_Exception) ;
 
/**************/
 
 
    void removeFile(in string file_name)                    raises (SALOME::SALOME_Exception);
 
    void removeFiles();
 
/**************/
 
 
    Engines::files getFilesInfos();
 
 
    Engines::file  getFileInfos(in string file_name) raises (SALOME::SALOME_Exception);
 
    Engines::SfState getSalome_fileState();
 
 
 
    void setContainer(in Engines::Container container);
  };
 
  interface fileRef
  {
    readonly attribute string origFileName;
    readonly attribute string refMachine;
 
    Container getContainer();
 
    boolean addRef(in string machine,
                   in string fileName);
 
    string getRef(in string machine);
  };
};
 
#endif