src/runtime/SalomeContainerHelper.cxx

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