Workload manager and attach on cloning.

diff --git a/src/engine/Task.hxx b/src/engine/Task.hxx
index 590ebf20da6b5825381bc3f937f7f12ec9f15519..5d1d39b1c94fb81050ccf36c2dea88a869a5b8f5 100644 (file)
--- a/src/engine/Task.hxx
+++ b/src/engine/Task.hxx
@@ -55,6 +55,7 @@ namespace YACS
       virtual void imposeResource(const std::string& resource_name,
                                   const std::string& container_name) {}
       virtual bool canAcceptImposedResource() { return false;}
+      virtual bool hasImposedResource()const { return false;}
       virtual ~Task();
     };
   }

diff --git a/src/runtime/PythonNode.cxx b/src/runtime/PythonNode.cxx
index a7b850dbbd15eaf3468ed83bf665a95d17566234..05ca1a7502d78da6c36210f1620c37a73ea9e9b3 100644 (file)
--- a/src/runtime/PythonNode.cxx
+++ b/src/runtime/PythonNode.cxx
@@ -96,22 +96,22 @@ void PythonEntry::loadRemoteContainer(InlineNode *reqNode)
   bool isContAlreadyStarted(false);
   if(container)
     {
-      isContAlreadyStarted=container->isAlreadyStarted(reqNode);
-      if(!isContAlreadyStarted)
+      try
+      {
+        if(hasImposedResource())
+          container->start(reqNode, _imposedResource, _imposedContainer);
+        else
         {
-          try
-          {
-            if(hasImposedResource())
-              container->start(reqNode, _imposedResource, _imposedContainer);
-            else
-              container->start(reqNode);
-          }
-          catch(Exception& e)
-          {
-              reqNode->setErrorDetails(e.what());
-              throw e;
-          }
+          isContAlreadyStarted=container->isAlreadyStarted(reqNode);
+          if(!isContAlreadyStarted)
+            container->start(reqNode);
         }
+      }
+      catch(Exception& e)
+      {
+          reqNode->setErrorDetails(e.what());
+          throw e;
+      }
     }
   else
     {
@@ -742,6 +742,11 @@ bool PythonNode::canAcceptImposedResource()
   return _container != nullptr && _container->canAcceptImposedResource();
 }
 
+bool PythonNode::hasImposedResource()const
+{
+  return PythonEntry::hasImposedResource();
+}
+
 std::string PythonNode::pythonEntryName()const
 {
   if(isUsingPythonCache())
@@ -1382,3 +1387,9 @@ bool PyFuncNode::canAcceptImposedResource()
 {
   return _container != nullptr && _container->canAcceptImposedResource();
 }
+
+bool PyFuncNode::hasImposedResource()const
+{
+  return PythonEntry::hasImposedResource();
+}
+

diff --git a/src/runtime/PythonNode.hxx b/src/runtime/PythonNode.hxx
index 12ba7891d2815e7c4a5c32a4f88729c599133e85..d13b9570818e208b9c05ff31d687f28b9559cb9b 100644 (file)
--- a/src/runtime/PythonNode.hxx
+++ b/src/runtime/PythonNode.hxx
@@ -50,7 +50,7 @@ namespace YACS
       Engines::Container_var loadPythonAdapter(InlineNode *reqNode, bool& isInitializeRequested);
       void loadRemoteContext(InlineNode *reqNode, Engines::Container_ptr objContainer, bool isInitializeRequested);
       static std::string GetContainerLog(const std::string& mode, Container *container, const Task *askingTask);
-      bool hasImposedResource()const;
+      virtual bool hasImposedResource()const;
     protected:
       PyObject *_context;
       PyObject *_pyfuncSer;
@@ -91,6 +91,7 @@ namespace YACS
       void imposeResource(const std::string& resource_name,
                           const std::string& container_name) override;
       bool canAcceptImposedResource()override;
+      bool hasImposedResource()const override;
       bool isUsingPythonCache()const;
       std::string getContainerLog();
       PythonNode* cloneNode(const std::string& name);
@@ -139,6 +140,7 @@ namespace YACS
       void imposeResource(const std::string& resource_name,
                           const std::string& container_name) override;
       bool canAcceptImposedResource()override;
+      bool hasImposedResource()const override;
       std::string getContainerLog();
       PyFuncNode* cloneNode(const std::string& name);
       virtual std::string typeName() { return "YACS__ENGINE__PyFuncNode"; }

diff --git a/src/runtime/SalomeContainer.cxx b/src/runtime/SalomeContainer.cxx
index 150b520482c765347bb6d936a77245ef70504f09..b094092295df53e6c77411f7375ad4eb13c6b958 100644 (file)
--- a/src/runtime/SalomeContainer.cxx
+++ b/src/runtime/SalomeContainer.cxx
@@ -230,12 +230,18 @@ void SalomeContainer::start(const Task *askingNode,
                             const std::string& resource_name,
                             const std::string& container_name)
 {
-  if(canAcceptImposedResource())
+  if(canAcceptImposedResource()
+    && askingNode != nullptr
+    && askingNode->hasImposedResource())
   {
     SalomeContainerTools tempSct = _sct;
     tempSct.setProperty("name", resource_name);
     tempSct.setProperty("container_name", container_name);
-    SalomeContainerTools::Start(_componentNames,_launchModeType,tempSct,_shutdownLevel,this,askingNode);
+    //SalomeContainerTools::Start(_componentNames,_launchModeType,tempSct,_shutdownLevel,this,askingNode);
+    // components are not supported yet on this kind of start
+    std::vector<std::string> noComponentNames;
+    int shutdownLevel = 999;
+    SalomeContainerTools::Start(noComponentNames,_launchModeType,tempSct,shutdownLevel,this,askingNode);
   }
   else
     start(askingNode);

diff --git a/src/runtime/SalomeContainerHelper.cxx b/src/runtime/SalomeContainerHelper.cxx
index 12c4d456770f582743a4248914d6ea9524e0b888..f04ba2221a68b0e32954ab3d63e12721a8a226d9 100644 (file)
--- a/src/runtime/SalomeContainerHelper.cxx
+++ b/src/runtime/SalomeContainerHelper.cxx
@@ -135,39 +135,90 @@ SalomeContainerMultiHelper *SalomeContainerMultiHelper::deepCpyOnlyStaticInfo()
 
 Engines::Container_var SalomeContainerMultiHelper::getContainer(const Task *askingNode) const
 {
+  std::unique_lock<std::mutex> lock(_data_mutex);
   const ComponentInstance *inst(askingNode?askingNode->getComponent():0);
-  std::map<const ComponentInstance *,Engines::Container_var>::const_iterator it(_trueContainers.find(inst));
-  if(it!=_trueContainers.end())
-    return (*it).second;
+  if(inst == nullptr && askingNode != nullptr && askingNode->hasImposedResource())
+  {
+    std::map<const Task *,Engines::Container_var>::const_iterator it(_containersForTasks.find(askingNode));
+    if(it!=_containersForTasks.end())
+      return (*it).second;
+    else
+      return Engines::Container::_nil();
+  }
   else
-    return Engines::Container::_nil();
+  {
+    std::map<const ComponentInstance *,Engines::Container_var>::const_iterator it(_containersForComponents.find(inst));
+    if(it!=_containersForComponents.end())
+      return (*it).second;
+    else
+      return Engines::Container::_nil();
+  }
 }
 
 bool SalomeContainerMultiHelper::isAlreadyStarted(const Task *askingNode) const
 {
+  std::unique_lock<std::mutex> lock(_data_mutex);
   const ComponentInstance *inst(askingNode?askingNode->getComponent():0);
-  if(_trueContainers.count(inst)==0)
-    return false;
+  if(inst == nullptr && askingNode != nullptr && askingNode->hasImposedResource())
+  {
+    return _containersForTasks.count(askingNode) > 0;
+  }
   else
-    return true;
+  {
+    if(_containersForComponents.count(inst)==0)
+      return false;
+    else
+      return true;
+  }
 }
 
 void SalomeContainerMultiHelper::setContainer(const Task *askingNode, Engines::Container_var cont)
 {
+  std::unique_lock<std::mutex> lock(_data_mutex);
   const ComponentInstance *inst(askingNode?askingNode->getComponent():0);
-  _trueContainers[inst]=cont;
+  if(inst == nullptr && askingNode != nullptr && askingNode->hasImposedResource())
+  {
+    _containersForTasks[askingNode] = cont;
+  }
+  else
+  {
+    _containersForComponents[inst]=cont;
 #ifdef REFCNT
     std::map<const ComponentInstance *, Engines::Container_var >::const_iterator it;
-    for(it = _trueContainers.begin(); it != _trueContainers.end(); ++it)
+    for(it = _containersForComponents.begin(); it != _containersForComponents.end(); ++it)
       {
         DEBTRACE(it->second->_PR_getobj()->pd_refCount );
       }
 #endif
+  }
 }
 
 void SalomeContainerMultiHelper::shutdown()
 {
-  for(std::map<const ComponentInstance *, Engines::Container_var >::const_iterator it = _trueContainers.begin(); it != _trueContainers.end(); ++it)
+  std::unique_lock<std::mutex> lock(_data_mutex);
+  for(std::map<const Task *, Engines::Container_var >::const_iterator it = _containersForTasks.begin();
+      it != _containersForTasks.end(); ++it)
+  {
+    try
+    {
+        DEBTRACE("shutdown SALOME container: " );
+        CORBA::String_var containerName=it->second->name();
+        DEBTRACE(containerName);
+        it->second->Shutdown();
+        std::cerr << "shutdown SALOME container: " << containerName << std::endl;
+    }
+    catch(CORBA::Exception&)
+    {
+        DEBTRACE("Unexpected CORBA failure detected." );
+    }
+    catch(...)
+    {
+        DEBTRACE("Unknown exception ignored." );
+    }
+  }
+  _containersForTasks.clear();
+
+  for(std::map<const ComponentInstance *, Engines::Container_var >::const_iterator it = _containersForComponents.begin(); it != _containersForComponents.end(); ++it)
     {
       try
       {
@@ -186,7 +237,7 @@ void SalomeContainerMultiHelper::shutdown()
           DEBTRACE("Unknown exception ignored." );
       }
     }
-  _trueContainers.clear();
+  _containersForComponents.clear();
 }
 
 SalomeContainerMultiHelper::~SalomeContainerMultiHelper()

diff --git a/src/runtime/SalomeContainerHelper.hxx b/src/runtime/SalomeContainerHelper.hxx
index 74c7d0dcd3a805322d9d9a49a5ed76eec471382f..db0be9f7f1dbebefb1c323b8765ac286896d47d1 100644 (file)
--- a/src/runtime/SalomeContainerHelper.hxx
+++ b/src/runtime/SalomeContainerHelper.hxx
@@ -29,6 +29,7 @@
 
 #include <map>
 #include <string>
+#include <mutex>
 
 namespace YACS
 {
@@ -89,7 +90,9 @@ namespace YACS
       static const char TYPE_NAME[];
       static const char DFT_LAUNCH_MODE[];
     private:
-      std::map<const ComponentInstance *,Engines::Container_var> _trueContainers;
+      std::map<const ComponentInstance *,Engines::Container_var> _containersForComponents;
+      std::map<const Task *,Engines::Container_var> _containersForTasks;
+      mutable std::mutex _data_mutex;
     };
   }
 }

diff --git a/src/runtime/SalomeContainerTools.cxx b/src/runtime/SalomeContainerTools.cxx
index 6cc052191b4088c6f05fef771832c916dd389550..a6c29fe105204de414cbb3dc16bf2bbfe3d8b32e 100644 (file)
--- a/src/runtime/SalomeContainerTools.cxx
+++ b/src/runtime/SalomeContainerTools.cxx
@@ -16,7 +16,7 @@
 //
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
-
+#define _DEVDEBUG_
 #include "SalomeContainerTools.hxx"
 #include "SALOME_LifeCycleCORBA.hxx"
 #include "SALOME_NamingService.hxx"
@@ -334,7 +334,7 @@ void SalomeContainerToolsBase::Start(const std::vector<std::string>& compoNames,
 
   bool isEmptyName;
   std::string str(sct.getNotNullContainerName(cont,askingNode,isEmptyName));
-  DEBTRACE("SalomeContainer::start " << str <<";"<< _sct.getHostName() <<";"<<_type);
+  DEBTRACE("SalomeContainer::start " << str <<";"<< sct.getHostName() );
 
   // Finalize parameters with components found in the container
 
@@ -370,6 +370,7 @@ void SalomeContainerToolsBase::Start(const std::vector<std::string>& compoNames,
       myparams.mode="get";
       try
       {
+          DEBTRACE("GiveContainer " << str << " mode " << myparams.mode);
           trueCont=contManager->GiveContainer(myparams);
       }
       catch( const SALOME::SALOME_Exception& ex )
@@ -386,13 +387,13 @@ void SalomeContainerToolsBase::Start(const std::vector<std::string>& compoNames,
       if(!CORBA::is_nil(trueCont))
         {
           shutdownLevel=3;
-          DEBTRACE( "container found: " << str << " " << _shutdownLevel );
+          DEBTRACE( "container found: " << str << " " << shutdownLevel );
         }
       else
         {
           shutdownLevel=2;
           myparams.mode="start";
-          DEBTRACE( "container not found: " << str << " " << _shutdownLevel);
+          DEBTRACE( "container not found: " << str << " " << shutdownLevel);
         }
     }
 
@@ -403,6 +404,7 @@ void SalomeContainerToolsBase::Start(const std::vector<std::string>& compoNames,
     {
           // --- GiveContainer is used in batch mode to retreive launched containers,
           //     and is equivalent to StartContainer when not in batch.
+          DEBTRACE("GiveContainer " << str << " mode " << myparams.mode);
           trueCont=contManager->GiveContainer(myparams);
     }
     catch( const SALOME::SALOME_Exception& ex )
@@ -414,7 +416,8 @@ void SalomeContainerToolsBase::Start(const std::vector<std::string>& compoNames,
     }
     catch(CORBA::COMM_FAILURE&)
     {
-      std::cerr << "SalomeContainer::start : CORBA Comm failure detected. Make another try!" << std::endl;
+      //std::cerr << "SalomeContainer::start : CORBA Comm failure detected. Make another try!" << std::endl;
+      DEBTRACE("SalomeContainer::start :" << str << " :CORBA Comm failure detected. Make another try!");
       nbTries++;
       if(nbTries > 5)
         throw Exception("SalomeContainer::start : Unable to launch container in Salome : CORBA Comm failure detected");
@@ -428,10 +431,12 @@ void SalomeContainerToolsBase::Start(const std::vector<std::string>& compoNames,
   if(CORBA::is_nil(trueCont))
     throw Exception("SalomeContainer::start : Unable to launch container in Salome. Check your CatalogResources.xml file");
 
+  // TODO : thread safety!
   schelp->setContainer(askingNode,trueCont);
 
   CORBA::String_var containerName(trueCont->name()),hostName(trueCont->getHostName());
-  std::cerr << "SalomeContainer launched : " << containerName << " " << hostName << " " << trueCont->getPID() << std::endl;
+  //std::cerr << "SalomeContainer launched : " << containerName << " " << hostName << " " << trueCont->getPID() << std::endl;
+  DEBTRACE("SalomeContainer launched : " << containerName << " " << hostName << " " << trueCont->getPID() );
 }
 
 CORBA::Object_ptr SalomeContainerToolsBase::LoadComponent(SalomeContainerHelper *launchModeType, Container *cont, Task *askingNode)