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();
};
}
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
{
return _container != nullptr && _container->canAcceptImposedResource();
}
+bool PythonNode::hasImposedResource()const
+{
+ return PythonEntry::hasImposedResource();
+}
+
std::string PythonNode::pythonEntryName()const
{
if(isUsingPythonCache())
{
return _container != nullptr && _container->canAcceptImposedResource();
}
+
+bool PyFuncNode::hasImposedResource()const
+{
+ return PythonEntry::hasImposedResource();
+}
+
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;
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);
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"; }
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);
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
{
DEBTRACE("Unknown exception ignored." );
}
}
- _trueContainers.clear();
+ _containersForComponents.clear();
}
SalomeContainerMultiHelper::~SalomeContainerMultiHelper()
#include <map>
#include <string>
+#include <mutex>
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;
};
}
}
//
// 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"
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
myparams.mode="get";
try
{
+ DEBTRACE("GiveContainer " << str << " mode " << myparams.mode);
trueCont=contManager->GiveContainer(myparams);
}
catch( const SALOME::SALOME_Exception& ex )
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);
}
}
{
// --- 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 )
}
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");
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)