src/runtime/SalomeContainerHelper.cxx

   1 // Copyright (C) 2006-2022  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 #include "SalomeContainerHelper.hxx"
  21
  22 #include "ServiceNode.hxx"
  23 #include "YacsTrace.hxx"
  24
  25 #include <sstream>
  26 #include <iostream>
  27
  28 using namespace YACS::ENGINE;
  29 using namespace std;
  30
  31 const char SalomeContainerMonoHelper::TYPE_NAME[]="mono";
  32
  33 const char SalomeContainerMonoHelper::DFT_LAUNCH_MODE[]="start";
  34
  35 const char SalomeContainerMultiHelper::TYPE_NAME[]="multi";
  36
  37 const char SalomeContainerMultiHelper::DFT_LAUNCH_MODE[]="getorstart";
  38
  39 SalomeContainerHelper::~SalomeContainerHelper()
  40 {
  41 }
  42
  43 SalomeContainerMonoHelper::SalomeContainerMonoHelper():_trueCont(Engines::Container::_nil())
  44 {
  45
  46 }
  47
  48 std::string SalomeContainerMonoHelper::getType() const
  49 {
  50   return TYPE_NAME;
  51 }
  52
  53 std::string SalomeContainerMonoHelper::getDftLaunchMode() const
  54 {
  55   return std::string(DFT_LAUNCH_MODE);
  56 }
  57
  58 SalomeContainerMonoHelper *SalomeContainerMonoHelper::deepCpyOnlyStaticInfo() const
  59 {
  60   return new SalomeContainerMonoHelper;
  61 }
  62
  63 Engines::Container_var SalomeContainerMonoHelper::getContainer(const Task *askingNode) const
  64 {
  65   return _trueCont;
  66 }
  67
  68 bool SalomeContainerMonoHelper::isAlreadyStarted(const Task *askingNode) const
  69 {
  70   if(CORBA::is_nil(_trueCont))
  71     return false;
  72   else
  73     return true;
  74 }
  75
  76 void SalomeContainerMonoHelper::setContainer(const Task *askingNode, Engines::Container_var cont)
  77 {
  78   _trueCont=cont;
  79 #ifdef REFCNT
  80     DEBTRACE(_trueCont->_PR_getobj()->pd_refCount );
  81 #endif
  82 }
  83
  84 bool SalomeContainerMonoHelper::isKernelContNull() const
  85 {
  86   return CORBA::is_nil(_trueCont);
  87 }
  88
  89 void SalomeContainerMonoHelper::shutdown()
  90 {
  91   if(CORBA::is_nil(_trueCont))
  92     return ;
  93   try
  94   {
  95       DEBTRACE("shutdown SALOME container: " );
  96       CORBA::String_var containerName=_trueCont->name();
  97       DEBTRACE(containerName);
  98       _trueCont->Shutdown();
  99       std::cerr << "shutdown SALOME container: " << containerName << std::endl;
 100   }
 101   catch(...)
 102   {
 103       DEBTRACE("Unknown exception ignored." );
 104   }
 105   _trueCont=Engines::Container::_nil();
 106 }
 107
 108 std::string SalomeContainerMonoHelper::getKernelContainerName() const
 109 {
 110   if(CORBA::is_nil(_trueCont))
 111     return std::string("NULL");
 112   CORBA::String_var containerName(_trueCont->name());
 113   std::string ret(containerName);
 114   return ret;
 115 }
 116
 117 SalomeContainerMonoHelper::~SalomeContainerMonoHelper()
 118 {
 119 }
 120
 121 std::string SalomeContainerMultiHelper::getType() const
 122 {
 123   return TYPE_NAME;
 124 }
 125
 126 std::string SalomeContainerMultiHelper::getDftLaunchMode() const
 127 {
 128   return std::string(DFT_LAUNCH_MODE);
 129 }
 130
 131 SalomeContainerMultiHelper *SalomeContainerMultiHelper::deepCpyOnlyStaticInfo() const
 132 {
 133   return new SalomeContainerMultiHelper;
 134 }
 135
 136 Engines::Container_var SalomeContainerMultiHelper::getContainer(const Task *askingNode) const
 137 {
 138   std::unique_lock<std::mutex> lock(_data_mutex);
 139   const ComponentInstance *inst(askingNode?askingNode->getComponent():0);
 140   if(inst == nullptr && askingNode != nullptr && askingNode->hasImposedResource())
 141   {
 142     std::map<const Task *,Engines::Container_var>::const_iterator it(_containersForTasks.find(askingNode));
 143     if(it!=_containersForTasks.end())
 144       return (*it).second;
 145     else
 146       return Engines::Container::_nil();
 147   }
 148   else
 149   {
 150     std::map<const ComponentInstance *,Engines::Container_var>::const_iterator it(_containersForComponents.find(inst));
 151     if(it!=_containersForComponents.end())
 152       return (*it).second;
 153     else
 154       return Engines::Container::_nil();
 155   }
 156 }
 157
 158 bool SalomeContainerMultiHelper::isAlreadyStarted(const Task *askingNode) const
 159 {
 160   std::unique_lock<std::mutex> lock(_data_mutex);
 161   const ComponentInstance *inst(askingNode?askingNode->getComponent():0);
 162   if(inst == nullptr && askingNode != nullptr && askingNode->hasImposedResource())
 163   {
 164     return _containersForTasks.count(askingNode) > 0;
 165   }
 166   else
 167   {
 168     if(_containersForComponents.count(inst)==0)
 169       return false;
 170     else
 171       return true;
 172   }
 173 }
 174
 175 void SalomeContainerMultiHelper::setContainer(const Task *askingNode, Engines::Container_var cont)
 176 {
 177   std::unique_lock<std::mutex> lock(_data_mutex);
 178   const ComponentInstance *inst(askingNode?askingNode->getComponent():0);
 179   if(inst == nullptr && askingNode != nullptr && askingNode->hasImposedResource())
 180   {
 181     _containersForTasks[askingNode] = cont;
 182   }
 183   else
 184   {
 185     _containersForComponents[inst]=cont;
 186 #ifdef REFCNT
 187     std::map<const ComponentInstance *, Engines::Container_var >::const_iterator it;
 188     for(it = _containersForComponents.begin(); it != _containersForComponents.end(); ++it)
 189       {
 190         DEBTRACE(it->second->_PR_getobj()->pd_refCount );
 191       }
 192 #endif
 193   }
 194 }
 195
 196 void SalomeContainerMultiHelper::shutdown()
 197 {
 198   std::unique_lock<std::mutex> lock(_data_mutex);
 199   for(std::map<const Task *, Engines::Container_var >::const_iterator it = _containersForTasks.begin();
 200       it != _containersForTasks.end(); ++it)
 201   {
 202     try
 203     {
 204         DEBTRACE("shutdown SALOME container: " );
 205         CORBA::String_var containerName=it->second->name();
 206         DEBTRACE(containerName);
 207         it->second->Shutdown();
 208         std::cerr << "shutdown SALOME container: " << containerName << std::endl;
 209     }
 210     catch(CORBA::Exception&)
 211     {
 212         DEBTRACE("Unexpected CORBA failure detected." );
 213     }
 214     catch(...)
 215     {
 216         DEBTRACE("Unknown exception ignored." );
 217     }
 218   }
 219   _containersForTasks.clear();
 220
 221   for(std::map<const ComponentInstance *, Engines::Container_var >::const_iterator it = _containersForComponents.begin(); it != _containersForComponents.end(); ++it)
 222     {
 223       try
 224       {
 225           DEBTRACE("shutdown SALOME container: " );
 226           CORBA::String_var containerName=it->second->name();
 227           DEBTRACE(containerName);
 228           it->second->Shutdown();
 229           std::cerr << "shutdown SALOME container: " << containerName << std::endl;
 230       }
 231       catch(CORBA::Exception&)
 232       {
 233           DEBTRACE("Unexpected CORBA failure detected." );
 234       }
 235       catch(...)
 236       {
 237           DEBTRACE("Unknown exception ignored." );
 238       }
 239     }
 240   _containersForComponents.clear();
 241 }
 242
 243 SalomeContainerMultiHelper::~SalomeContainerMultiHelper()
 244 {
 245 }