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(const Container& other, const SalomeContainerTools& sct, SalomeContainerHelper *lmt,
  68                                  const std::vector<std::string>& componentNames, int shutdownLev):Container(other),_componentNames(componentNames),
  69                                      _launchModeType(lmt),_shutdownLevel(shutdownLev),_sct(sct)
  70 {
  71   if(lmt)
  72     lmt->incrRef();
  73 }
  74
  75 SalomeContainer::~SalomeContainer()
  76 {
  77   _launchModeType->decrRef();
  78 }
  79
  80 void SalomeContainer::lock()
  81 {
  82   _mutex.lock();
  83 }
  84
  85 void SalomeContainer::unLock()
  86 {
  87   _mutex.unLock();
  88 }
  89
  90 Container *SalomeContainer::clone() const
  91 {
  92   if(_isAttachedOnCloning)
  93     {
  94       incrRef();
  95       return (Container*) (this);
  96     }
  97   else
  98     return new SalomeContainer(*this);
  99 }
 100
 101 Container *SalomeContainer::cloneAlways() const
 102 {
 103   return new SalomeContainer(*this);
 104 }
 105
 106 void SalomeContainer::checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception)
 107 {
 108   if(inst->getKind()!=SalomeComponent::KIND)
 109     throw Exception("SalomeContainer::checkCapabilityToDealWith : SalomeContainer is not able to deal with this type of ComponentInstance.");
 110 }
 111
 112 void SalomeContainer::setProperty(const std::string& name, const std::string& value)
 113 {
 114   if (name == "type")
 115     {
 116       if (value == SalomeContainerMonoHelper::TYPE_NAME)
 117         {
 118           _launchModeType->decrRef();
 119           _launchModeType=new SalomeContainerMonoHelper;
 120         }
 121       else if (value == SalomeContainerMultiHelper::TYPE_NAME)
 122         {
 123           _launchModeType->decrRef();
 124           _launchModeType=new SalomeContainerMultiHelper;
 125         }
 126       else
 127         throw Exception("SalomeContainer::setProperty : type value is not correct (mono or multi): " + value);
 128       return ;
 129     }
 130   _sct.setProperty(name,value);
 131 }
 132
 133 std::string SalomeContainer::getProperty(const std::string& name) const
 134 {
 135   return _sct.getProperty(name);
 136 }
 137
 138 void SalomeContainer::clearProperties()
 139 {
 140   _sct.clearProperties();
 141 }
 142
 143 void SalomeContainer::addComponentName(const std::string& name)
 144 {
 145   _componentNames.push_back(name);
 146 }
 147
 148 void SalomeContainer::addToResourceList(const std::string& name)
 149 {
 150   _sct.addToResourceList(name);
 151 }
 152
 153 //! Load a component instance in this container
 154 /*!
 155  * \param inst the component instance to load
 156  */
 157 CORBA::Object_ptr SalomeContainer::loadComponent(Task *askingNode)
 158 {
 159   return SalomeContainerTools::LoadComponent(_launchModeType,this,askingNode);
 160 }
 161
 162 //! Get the container placement id for a component instance
 163 /*!
 164  * \param inst the component instance
 165  * \return the placement id
 166  */
 167 std::string SalomeContainer::getPlacementId(const Task *askingNode) const
 168 {
 169   return SalomeContainerTools::GetPlacementId(_launchModeType,this,askingNode);
 170 }
 171
 172 //! Get the container full path for a component instance
 173 /*!
 174  * \param inst the component instance
 175  * \return the full placement id
 176  */
 177 std::string SalomeContainer::getFullPlacementId(const Task *askingNode) const
 178 {
 179   return SalomeContainerTools::GetFullPlacementId(_launchModeType,this,askingNode);
 180 }
 181
 182 //! Check if the component instance container is already started
 183 /*!
 184  * \param inst the component instance
 185  * \return true, if the container is already started, else false
 186  */
 187 bool SalomeContainer::isAlreadyStarted(const Task *askingNode) const
 188 {
 189   return _launchModeType->isAlreadyStarted(askingNode);
 190 }
 191
 192 Engines::Container_ptr SalomeContainer::getContainerPtr(const Task *askingNode) const
 193 {
 194   return Engines::Container::_duplicate(_launchModeType->getContainer(askingNode));
 195 }
 196
 197 //! Start a salome container (true salome container not yacs one) with given ContainerParameters (_params)
 198 /*!
 199  * \param inst the component instance
 200  */
 201 void SalomeContainer::start(const Task *askingNode) throw(YACS::Exception)
 202 {
 203   SalomeContainerTools::Start(_componentNames,_launchModeType,_sct,_shutdownLevel,this,askingNode);
 204 }
 205
 206 void SalomeContainer::shutdown(int level)
 207 {
 208   DEBTRACE("SalomeContainer::shutdown: " << _name << "," << level << "," << _shutdownLevel);
 209   if(level < _shutdownLevel)
 210     return;
 211
 212   _shutdownLevel=999;
 213   //shutdown the SALOME containers
 214   _launchModeType->shutdown();
 215 }
 216
 217 std::map<std::string,std::string> SalomeContainer::getResourceProperties(const std::string& name) const
 218 {
 219   return _sct.getResourceProperties(name);
 220 }
 221
 222 std::map<std::string,std::string> SalomeContainer::getProperties() const
 223 {
 224   return _sct.getProperties();
 225 }