src/runtime/SalomeContainer.cxx

   1 // Copyright (C) 2006-2014  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 //#define REFCNT
  21 //
  22 #ifdef REFCNT
  23 #define private public
  24 #define protected public
  25 #include <omniORB4/CORBA.h>
  26 #include <omniORB4/internal/typecode.h>
  27 #endif
  28
  29 #include "RuntimeSALOME.hxx"
  30 #include "SalomeContainer.hxx"
  31 #include "SalomeComponent.hxx"
  32 #include "ServiceNode.hxx"
  33 #include "Proc.hxx"
  34
  35 #include "SALOME_NamingService.hxx"
  36 #include "SALOME_LifeCycleCORBA.hxx"
  37 #include "SALOME_ContainerManager.hxx"
  38 #include "Basics_Utils.hxx"
  39 #include "OpUtil.hxx"
  40
  41 #include <sstream>
  42 #include <iostream>
  43
  44 #ifdef WIN32
  45 #include <process.h>
  46 #define getpid _getpid
  47 #endif
  48
  49 //#define _DEVDEBUG_
  50 #include "YacsTrace.hxx"
  51
  52 using namespace YACS::ENGINE;
  53 using namespace std;
  54
  55 SalomeContainer::SalomeContainer():_launchModeType(new SalomeContainerMonoHelper),_shutdownLevel(999)
  56 {
  57 }
  58
  59 SalomeContainer::SalomeContainer(const SalomeContainer& other)
  60 : Container(other),_componentNames(other._componentNames),
  61   _launchModeType(other._launchModeType->deepCpyOnlyStaticInfo()),
  62   _shutdownLevel(other._shutdownLevel),
  63   _sct(other._sct)
  64 {
  65 }
  66
  67 SalomeContainer::~SalomeContainer()
  68 {
  69   delete _launchModeType;
  70 }
  71
  72 void SalomeContainer::lock()
  73 {
  74   _mutex.lock();
  75 }
  76
  77 void SalomeContainer::unLock()
  78 {
  79   _mutex.unlock();
  80 }
  81
  82 Container *SalomeContainer::clone() const
  83 {
  84   if(_isAttachedOnCloning)
  85     {
  86       incrRef();
  87       return (Container*) (this);
  88     }
  89   else
  90     return new SalomeContainer(*this);
  91 }
  92
  93 Container *SalomeContainer::cloneAlways() const
  94 {
  95   return new SalomeContainer(*this);
  96 }
  97
  98 void SalomeContainer::checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception)
  99 {
 100   if(inst->getKind()!=SalomeComponent::KIND)
 101     throw Exception("SalomeContainer::checkCapabilityToDealWith : SalomeContainer is not able to deal with this type of ComponentInstance.");
 102 }
 103
 104 void SalomeContainer::setProperty(const std::string& name, const std::string& value)
 105 {
 106   if (name == "type")
 107     {
 108       if (value == SalomeContainerMonoHelper::TYPE_NAME)
 109         {
 110           delete _launchModeType;
 111           _launchModeType=new SalomeContainerMonoHelper;
 112         }
 113       else if (value == SalomeContainerMultiHelper::TYPE_NAME)
 114         {
 115           delete _launchModeType;
 116           _launchModeType=new SalomeContainerMultiHelper;
 117         }
 118       else
 119         throw Exception("SalomeContainer::setProperty : type value is not correct (mono or multi): " + value);
 120       return ;
 121     }
 122   _sct.setProperty(name,value);
 123 }
 124
 125 std::string SalomeContainer::getProperty(const std::string& name) const
 126 {
 127   return _sct.getProperty(name);
 128 }
 129
 130 void SalomeContainer::clearProperties()
 131 {
 132   _sct.clearProperties();
 133 }
 134
 135 void SalomeContainer::addComponentName(const std::string& name)
 136 {
 137   _componentNames.push_back(name);
 138 }
 139
 140 void SalomeContainer::addToResourceList(const std::string& name)
 141 {
 142   _sct.addToResourceList(name);
 143 }
 144
 145 //! Load a component instance in this container
 146 /*!
 147  * \param inst the component instance to load
 148  */
 149 CORBA::Object_ptr SalomeContainer::loadComponent(Task *askingNode)
 150 {
 151   return SalomeContainerTools::LoadComponent(_launchModeType,this,askingNode);
 152 }
 153
 154 //! Get the container placement id for a component instance
 155 /*!
 156  * \param inst the component instance
 157  * \return the placement id
 158  */
 159 std::string SalomeContainer::getPlacementId(const Task *askingNode) const
 160 {
 161   return SalomeContainerTools::GetPlacementId(_launchModeType,this,askingNode);
 162 }
 163
 164 //! Get the container full path for a component instance
 165 /*!
 166  * \param inst the component instance
 167  * \return the full placement id
 168  */
 169 std::string SalomeContainer::getFullPlacementId(const Task *askingNode) const
 170 {
 171   return SalomeContainerTools::GetFullPlacementId(_launchModeType,this,askingNode);
 172 }
 173
 174 //! Check if the component instance container is already started
 175 /*!
 176  * \param inst the component instance
 177  * \return true, if the container is already started, else false
 178  */
 179 bool SalomeContainer::isAlreadyStarted(const Task *askingNode) const
 180 {
 181   return _launchModeType->isAlreadyStarted(askingNode);
 182 }
 183
 184 Engines::Container_ptr SalomeContainer::getContainerPtr(const Task *askingNode) const
 185 {
 186   return Engines::Container::_duplicate(_launchModeType->getContainer(askingNode));
 187 }
 188
 189 //! Start a salome container (true salome container not yacs one) with given ContainerParameters (_params)
 190 /*!
 191  * \param inst the component instance
 192  */
 193 void SalomeContainer::start(const Task *askingNode) throw(YACS::Exception)
 194 {
 195   SalomeContainerTools::Start(_componentNames,_launchModeType,_sct,_shutdownLevel,this,askingNode);
 196 }
 197
 198 void SalomeContainer::shutdown(int level)
 199 {
 200   DEBTRACE("SalomeContainer::shutdown: " << _name << "," << level << "," << _shutdownLevel);
 201   if(level < _shutdownLevel)
 202     return;
 203
 204   _shutdownLevel=999;
 205   //shutdown the SALOME containers
 206   _launchModeType->shutdown();
 207 }
 208
 209 std::map<std::string,std::string> SalomeContainer::getResourceProperties(const std::string& name) const
 210 {
 211   return _sct.getResourceProperties(name);
 212 }
 213
 214 std::map<std::string,std::string> SalomeContainer::getProperties() const
 215 {
 216   return _sct.getProperties();
 217 }