{
namespace ENGINE
{
- class Container;
+ class Task;
class ServiceNode;
+ class Container;
class YACSLIBENGINE_EXPORT ComponentInstance : public PropertyInterface, public RefCounter
{
virtual void setContainer(Container *cont);
Container *getContainer() const { return _container; }
//! Load the component instance
- virtual void load(ServiceNode *askingNode) = 0;
+ virtual void load(Task *askingNode) = 0;
//! Unload the component instance
- virtual void unload(ServiceNode *askingNode) = 0;
+ virtual void unload(Task *askingNode) = 0;
//! Indicate if the component instance is loaded (true) or not
- virtual bool isLoaded(ServiceNode *askingNode) = 0;
+ virtual bool isLoaded(Task *askingNode) const = 0;
virtual void attachOnCloning() const;
virtual void dettachOnCloning() const;
bool isAttachedOnCloning() const;
setProperty((*it).first,(*it).second);
}
-void Container::shutdown(int level)
-{
-}
{
class ComponentInstance;
class Proc;
+ class Task;
/*!
* This is an abstract class, that represents an abstract process in which ComponentInstances can be launched and run.
* An instance of this will be mapped to one and only one physical container (except in the foreach context)
#endif
public:
//Execution only methods
- virtual bool isAlreadyStarted(const ComponentInstance *inst) const = 0;
- virtual void start(const ComponentInstance *inst) throw(Exception) = 0;
- virtual std::string getPlacementId(const ComponentInstance *inst) const = 0;
- virtual std::string getFullPlacementId(const ComponentInstance *inst) const = 0;
+ virtual bool isAlreadyStarted(const Task *askingNode) const = 0;
+ virtual void start(const Task *askingNode) throw(Exception) = 0;
+ virtual std::string getPlacementId(const Task *askingNode) const = 0;
+ virtual std::string getFullPlacementId(const Task *askingNode) const = 0;
//Edition only methods
virtual void attachOnCloning() const;
virtual void dettachOnCloning() const;
void setName(std::string name) { _name = name; };
void setProc(Proc* proc) { _proc = proc; };
Proc* getProc() { return _proc; };
- virtual void shutdown(int level);
+ virtual void shutdown(int level) = 0;
protected:
std::string _name;
mutable bool _isAttachedOnCloning;
return 0;
}
+const ComponentInstance *ElementaryNode::getComponent() const
+{
+ return 0;
+}
+
Container *ElementaryNode::getContainer()
{
return 0;
void init(bool start=true);
bool isDeployable() const;
ComponentInstance *getComponent();
+ const ComponentInstance *getComponent() const;
Container *getContainer();
YACS::StatesForNode getState() const;
void getReadyTasks(std::vector<Task *>& tasks);
#include "ComponentInstance.hxx"
#include "VisitorSaveState.hxx"
+#include "ServiceNode.hxx"
#include "ComposedNode.hxx"
#include <iostream>
{
containerName = cont->getName();
ComponentInstance *compo = task->getComponent();
- //if (compo)
- placement = cont->getFullPlacementId(compo);
+ ServiceNode *taskCast(dynamic_cast<ServiceNode *>(task));
+ if(taskCast)
+ placement = cont->getFullPlacementId(taskCast);
}
#ifdef WIN32
DWORD now = timeGetTime();
using namespace std;
-InlineNode::~InlineNode() { }
+InlineNode::~InlineNode()
+{
+ if(_container)
+ _container->decrRef();
+}
void InlineNode::accept(Visitor *visitor)
{
InlineFuncNode::~InlineFuncNode()
-{
- if(_container)
- _container->decrRef();
+{
}
void InlineFuncNode::accept(Visitor *visitor)
visitor->visitInlineFuncNode(this);
}
+/*!
+ * \param fname: name of the function contained in the script to execute
+ */
void InlineFuncNode::setFname(const std::string& fname)
{
_fname=fname;
:InlineNode(other,father),_fname(other._fname) { }
InlineFuncNode(const std::string& name):InlineNode(name) { }
public:
-//! Set the function name to use in node execution
-/*!
- * \param fname: name of the function contained in the script to execute
- */
+ //! Set the function name to use in node execution
virtual void setFname(const std::string& fname);
virtual std::string getFname() { return _fname; }
void accept(Visitor *visitor);
virtual ~InlineFuncNode();
- virtual std::string typeName() {return "YACS__ENGINE__InlineFuncNode";}
+ virtual std::string typeName() { return "YACS__ENGINE__InlineFuncNode"; }
virtual void checkBasicConsistency() const throw(Exception);
protected:
std::string _fname;
virtual void setProperty(const std::string& name,const std::string& value);
virtual std::string getProperty(const std::string& name);
- std::map<std::string,std::string> getProperties() { return _propertyMap; };
+ std::map<std::string,std::string> getProperties() const { return _propertyMap; };
virtual void setProperties(std::map<std::string,std::string> properties);
protected:
std::map<std::string,std::string> _propertyMap;
return _component;
}
+const ComponentInstance *ServiceNode::getComponent() const
+{
+ return _component;
+}
+
//! Return the associated container
Container *ServiceNode::getContainer()
{
virtual bool isDeployable() const;
virtual void setComponent(ComponentInstance* compo) throw(Exception);
virtual ComponentInstance *getComponent();
+ virtual const ComponentInstance *getComponent() const;
virtual Container *getContainer();
virtual void setRef(const std::string& ref);
virtual std::string getRef();
virtual void getCoupledTasks(std::set<Task*>& coupledSet) = 0;
virtual bool isDeployable() const = 0;
virtual ComponentInstance *getComponent() = 0;
+ virtual const ComponentInstance *getComponent() const = 0;
virtual Container *getContainer() = 0;
virtual YACS::StatesForNode getState() const = 0;
virtual void finished() = 0;
{
}
-void ComponentInstanceTest1::load(ServiceNode *askingNode)
+void ComponentInstanceTest1::load(Task *askingNode)
{
_loaded=true;
}
-void ComponentInstanceTest1::unload(ServiceNode *askingNode)
+void ComponentInstanceTest1::unload(Task *askingNode)
{
_loaded=false;
}
-bool ComponentInstanceTest1::isLoaded(ServiceNode *askingNode)
+bool ComponentInstanceTest1::isLoaded(Task *askingNode) const
{
return _loaded;
}
{
}
-void ComponentInstanceTest2::load(ServiceNode *askingNode)
+void ComponentInstanceTest2::load(Task *askingNode)
{
_loaded=true;
}
-void ComponentInstanceTest2::unload(ServiceNode *askingNode)
+void ComponentInstanceTest2::unload(Task *askingNode)
{
_loaded=false;
}
-bool ComponentInstanceTest2::isLoaded(ServiceNode *askingNode)
+bool ComponentInstanceTest2::isLoaded(Task *askingNode) const
{
return _loaded;
}
public:
ComponentInstanceTest1(const ComponentInstanceTest1& other);
ComponentInstanceTest1(const std::string& name);
- void load(ServiceNode *askingNode);
- void unload(ServiceNode *askingNode);
- bool isLoaded(ServiceNode *askingNode);
+ void load(Task *askingNode);
+ void unload(Task *askingNode);
+ bool isLoaded(Task *askingNode) const;
std::string getKind() const;
ServiceNode* createNode(const std::string& name);
ComponentInstance *clone() const;
public:
ComponentInstanceTest2(const ComponentInstanceTest2& other);
ComponentInstanceTest2(const std::string& name);
- void load(ServiceNode *askingNode);
- void unload(ServiceNode *askingNode);
- bool isLoaded(ServiceNode *askingNode);
+ void load(Task *askingNode);
+ void unload(Task *askingNode);
+ bool isLoaded(Task *askingNode) const;
std::string getKind() const;
ServiceNode* createNode(const std::string& name);
ComponentInstance *clone() const;
return stream.str();
}
-bool ContainerTest::isAlreadyStarted(const ComponentInstance *inst) const
+bool ContainerTest::isAlreadyStarted(const Task *askingNode) const
{
return _alreadyStarted;
}
-void ContainerTest::start(const ComponentInstance *inst) throw(YACS::Exception)
+void ContainerTest::start(const Task *askingNode) throw(YACS::Exception)
{
if(_alreadyStarted)
throw Exception("ContainerTest already started !!!!");
{
}
-bool ContainerTest2::isAlreadyStarted(const ComponentInstance *inst) const
+bool ContainerTest2::isAlreadyStarted(const Task *askingNode) const
{
return _alreadyStarted;
}
-void ContainerTest2::start(const ComponentInstance *inst) throw(YACS::Exception)
+void ContainerTest2::start(const Task *askingNode) throw(YACS::Exception)
{
if(_alreadyStarted)
throw Exception("ContainerTest already started !!!!");
ContainerTest();
std::string getPlacementInfo() const;
// implementation of compulsary methods
- bool isAlreadyStarted(const ComponentInstance *inst) const;
- void start(const ComponentInstance *inst) throw(Exception);
+ bool isAlreadyStarted(const Task *askingNode) const;
+ void start(const Task *askingNode) throw(Exception);
Container *clone() const;
Container *cloneAlways() const;
//
void lock() { }
void unLock() { }
void clearProperties() { }
+ void shutdown(int level) { }
void setProperty(const std::string& name,const std::string& value) { }
std::string getProperty(const std::string& name) const { }
std::map<std::string,std::string> getResourceProperties(const std::string& name) const { return std::map<std::string,std::string>(); }
std::map<std::string,std::string> getProperties() const { return std::map<std::string,std::string>(); }
//
- std::string getPlacementId(const ComponentInstance *inst) const { return ""; }
- std::string getFullPlacementId(const ComponentInstance *inst) const { return ""; }
+ std::string getPlacementId(const Task *askingNode) const { return ""; }
+ std::string getFullPlacementId(const Task *askingNode) const { return ""; }
static void initAllContainers();
protected:
void checkCapabilityToDealWith(const ComponentInstance *inst) const throw(Exception);
public:
ContainerTest2();
// implementation of compulsary methods
- bool isAlreadyStarted(const ComponentInstance *inst) const;
- void start(const ComponentInstance *inst) throw(Exception);
+ bool isAlreadyStarted(const Task *askingNode) const;
+ void start(const Task *askingNode) throw(Exception);
Container *clone() const;
Container *cloneAlways() const;
//
void lock() { }
void unLock() { }
void clearProperties() { }
+ void shutdown(int level) { }
void setProperty(const std::string& name,const std::string& value) { }
std::string getProperty(const std::string& name) const { }
std::map<std::string,std::string> getResourceProperties(const std::string& name) const { return std::map<std::string,std::string>(); }
std::map<std::string,std::string> getProperties() const { return std::map<std::string,std::string>(); }
//
- std::string getPlacementId(const ComponentInstance *inst) const { return ""; }
- std::string getFullPlacementId(const ComponentInstance *inst) const { return ""; }
+ std::string getPlacementId(const Task *askingNode) const { return ""; }
+ std::string getFullPlacementId(const Task *askingNode) const { return ""; }
static void initAllContainers();
protected:
void checkCapabilityToDealWith(const ComponentInstance *inst) const throw(Exception);
#include "ExecutorSwig.hxx"
#include "Dispatcher.hxx"
#include "Container.hxx"
+#include "HomogeneousPoolContainer.hxx"
#include "Logger.hxx"
#include "DeploymentTree.hxx"
#include "ComponentInstance.hxx"
%include <ComponentInstance.hxx>
%include <Container.hxx>
+%include <HomogeneousPoolContainer.hxx>
%include <InputPort.hxx>
%extend YACS::ENGINE::InputPort
{
SalomeContainerTools.hxx
SalomeContainerHelper.hxx
SalomeHPContainer.hxx
+ SalomeHPContainerTools.hxx
SALOMEDispatcher.hxx
SalomeProc.hxx
SalomePythonComponent.hxx
SalomeContainer.cxx
SalomeContainerTools.cxx
SalomeHPContainer.cxx
+ SalomeHPContainerTools.cxx
SalomeContainerHelper.cxx
PythonPorts.cxx
XMLNode.cxx
}
//! Unload the component
-void CORBAComponent::unload(ServiceNode *askingNode)
+void CORBAComponent::unload(Task *askingNode)
{
//Not implemented
std::cerr << "CORBAComponent::unload : not implemented " << std::endl;
}
//! Is the component instance already loaded ?
-bool CORBAComponent::isLoaded(ServiceNode *askingNode)
+bool CORBAComponent::isLoaded(Task *askingNode) const
{
if(CORBA::is_nil(_objComponent))
return false;
}
//! Load the component
-void CORBAComponent::load(ServiceNode *askingNode)
+void CORBAComponent::load(Task *askingNode)
{
DEBTRACE( "CORBAComponent::load" );
CORBA::ORB_ptr orb;
CORBAComponent(const std::string& name);
CORBAComponent(const CORBAComponent& other);
virtual ~CORBAComponent();
- virtual void load(ServiceNode *askingNode);
- virtual void unload(ServiceNode *askingNode);
- virtual bool isLoaded(ServiceNode *askingNode);
+ virtual void load(Task *askingNode);
+ virtual void unload(Task *askingNode);
+ virtual bool isLoaded(Task *askingNode) const;
virtual ServiceNode* createNode(const std::string& name);
virtual ComponentInstance* clone() const;
virtual std::string getFileRepr() const;
}
//! CppComponent constructor
-CppComponent::CppComponent(const std::string &name) : ComponentInstance(name)
+CppComponent::CppComponent(const std::string &name) : ComponentInstance(name), __obj(0), __run(0),__terminate(0)
{
_container = getRuntime()->createContainer(CppNode::KIND);
- if (!_container->isAlreadyStarted(this))
- _container->start(this);
-
+ /* This part of code has been commented because the load part is supposed to do that !
+ if (!_container->isAlreadyStarted(0))
+ _container->start(0);
CppContainer * _containerC = dynamic_cast<CppContainer *> (_container);
- _containerC->createInternalInstance(name, __obj, __run, __terminate);
+ _containerC->createInternalInstance(name, __obj, __run, __terminate);*/
}
//! CppComponent copy constructor
-CppComponent::CppComponent(const CppComponent& other) : ComponentInstance(other._compoName), __run(other.__run),
- __terminate(other.__terminate), __obj(0)
+CppComponent::CppComponent(const CppComponent& other) : ComponentInstance(other._compoName), __obj(0), __run(0),__terminate(0)
{
_container = getRuntime()->createContainer(CppNode::KIND);
- if (!_container->isAlreadyStarted(this))
- _container->start(this);
-
+ /* This part of code has been commented because the load part is supposed to do that !
+ if (!_container->isAlreadyStarted(0))
+ _container->start(0);
CppContainer * _containerC = dynamic_cast<CppContainer *> (_container);
- _containerC->createInternalInstance(_compoName, __obj, __run, __terminate);
+ _containerC->createInternalInstance(_compoName, __obj, __run, __terminate);*/
}
CppComponent::~CppComponent()
{
- DEBTRACE("CppComponent::~CppComponent()");
- if (__terminate) __terminate(&__obj);
- if (_container)
- ((CppContainer *) _container)->unregisterComponentInstance(this);
+ DEBTRACE("CppComponent::~CppComponent()");
+ if (__terminate) __terminate(&__obj);
+ if (_container)
+ ((CppContainer *) _container)->unregisterComponentInstance(this);
}
void CppComponent::run (const char * service, int nbIn, int nbOut,
}
//! Unload the component
-void CppComponent::unload(ServiceNode *askingNode)
+void CppComponent::unload(Task *askingNode)
{
//Not implemented
DEBTRACE("CppComponent::unload : not implemented ");
}
//! Is the component instance already loaded ?
-bool CppComponent::isLoaded(ServiceNode *askingNode)
+bool CppComponent::isLoaded(Task *askingNode) const
{
return NULL != __obj;
}
-void CppComponent::load(ServiceNode *askingNode)
+void CppComponent::load(Task *askingNode)
{
- if (!_container) {
- _container = getRuntime()->createContainer(CppNode::KIND);
- }
-
- if(_container) {
-
- CppContainer * containerC= dynamic_cast< CppContainer *> (_container);
-
+ if (!_container)
+ {
+ _container = getRuntime()->createContainer(CppNode::KIND);
+ }
+
+ if(_container)
+ {
+ CppContainer *containerC(dynamic_cast< CppContainer *> (_container));
+ if(!containerC)
+ throw Exception("The type of container should be CPP for component CPP !");
containerC->lock();//To be sure
- if(!_container->isAlreadyStarted(this))
+ if(!_container->isAlreadyStarted(askingNode))
{
try
- {
- _container->start(this);
- }
+ {
+ _container->start(askingNode);
+ }
catch(Exception& e)
- {
+ {
containerC->unLock();
throw e;
- }
+ }
}
containerC->unLock();
containerC->lock();//To be sure
-
- bool isLoadable = containerC->loadComponentLibrary(_compoName);
+
+ bool isLoadable(containerC->loadComponentLibrary(_compoName));
if (isLoadable)
containerC->createInternalInstance(_compoName, __obj, __run, __terminate);
-
+
if(NULL == __obj)
{
containerC->unLock();
containerC->unLock();
return;
}
-
}
ServiceNode* CppComponent::createNode(const std::string& name)
static const char KIND[];
virtual std::string getKind() const;
- virtual void load(ServiceNode *askingNode);
- virtual void unload(ServiceNode *askingNode);
- virtual bool isLoaded(ServiceNode *askingNode);
+ virtual void load(Task *askingNode);
+ virtual void unload(Task *askingNode);
+ virtual bool isLoaded(Task *askingNode) const;
virtual ServiceNode* createNode(const std::string& name);
virtual YACS::ENGINE::ComponentInstance* clone() const;
_mutex.unlock();
}
-bool CppContainer::isAlreadyStarted(const ComponentInstance *inst) const
+bool CppContainer::isAlreadyStarted(const Task *askingNode) const
{
return NULL != _trueCont;
}
-void CppContainer::start(const ComponentInstance *inst) throw (YACS::Exception)
+void CppContainer::start(const Task *askingNode) throw (YACS::Exception)
{
_trueCont = LocalContainer::get();
}
+void CppContainer::shutdown(int level)
+{
+
+}
+
Container *CppContainer::clone() const
{
if(_isAttachedOnCloning)
}
bool CppContainer::loadComponentLibrary(const std::string & componentName) throw (YACS::Exception)
-{
- if (_trueCont)
{
- LocalLibrary L = _trueCont->loadComponentLibrary(componentName);
- return L.good();
+ if (_trueCont)
+ {
+ LocalLibrary L = _trueCont->loadComponentLibrary(componentName);
+ return L.good();
}
- else
+ else
{
- std::string mesg = "CppContainer not started";
- throw YACS::Exception(mesg);
+ std::string mesg = "CppContainer not started";
+ throw YACS::Exception(mesg);
+ }
+ return false;
}
- return false;
-}
CppComponent * CppContainer::createComponentInstance(const std::string & componentName, int /* studyID */)
{
- DEBTRACE("CppContainer::createComponentInstance");
- if (_trueCont)
- return _trueCont->createComponentInstance(componentName.c_str());
- else
+ DEBTRACE("CppContainer::createComponentInstance");
+ if (_trueCont)
+ return _trueCont->createComponentInstance(componentName.c_str());
+ else
{
- std::string mesg = "CppContainer not started";
- throw YACS::Exception(mesg);
+ std::string mesg = "CppContainer not started";
+ throw YACS::Exception(mesg);
}
}
void CppContainer::createInternalInstance(const std::string & name, void *&obj,
RunFunction &r, TerminateFunction &t)
{
- DEBTRACE("CppContainer::createInternalInstance");
- if (_trueCont)
- _trueCont->createInternalInstance(name.c_str(), obj, r, t);
- else
- {
- std::string mesg = "CppContainer not started";
- throw YACS::Exception(mesg);
- }
+ DEBTRACE("CppContainer::createInternalInstance");
+ if (_trueCont)
+ _trueCont->createInternalInstance(name.c_str(), obj, r, t);
+ else
+ {
+ std::string mesg = "CppContainer not started";
+ throw YACS::Exception(mesg);
+ }
}
-void CppContainer::unregisterComponentInstance(CppComponent * C)
+void CppContainer::unregisterComponentInstance(CppComponent *compo)
{
- if (_trueCont)
- {
- _trueCont->unregisterComponentInstance(C);
- }
+ if (_trueCont)
+ _trueCont->unregisterComponentInstance(compo);
}
-std::string CppContainer::getPlacementId(const ComponentInstance *inst) const
+std::string CppContainer::getPlacementId(const Task *askingNode) const
{
return "/";
}
-std::string CppContainer::getFullPlacementId(const ComponentInstance *inst) const
+std::string CppContainer::getFullPlacementId(const Task *askingNode) const
{
return "/";
}
void LocalContainer::destroy()
{
- if (NULL == _singleton)
- return;
-
- // destroy all component instances
- _instance_mapMutex.lock(); // lock
- std::multimap<std::string, CppComponent *>::iterator iI, iJ;
- for (iI=_instance_map.begin(); iI != _instance_map.end(); iI = iJ)
+ if (NULL == _singleton)
+ return;
+
+ // destroy all component instances
+ _instance_mapMutex.lock(); // lock
+ std::multimap<std::string, CppComponent *>::iterator iI, iJ;
+ for (iI=_instance_map.begin(); iI != _instance_map.end(); iI = iJ)
{
iJ = iI++;
iI->second->setContainer(NULL);
delete iI->second;
}
- _instance_map.clear();
- _instance_mapMutex.unlock(); // unlock
-
- // unload all dynamic libraries
- _library_mapMutex.lock();
- std::map<std::string, LocalLibrary>::iterator iL;
- for (iL=_library_map.begin(); iL != _library_map.end(); iL++)
- dlclose(iL->second.handle);
- _library_map.clear();
- _library_mapMutex.unlock();
-
- delete _singleton;
- _singleton = NULL;
+ _instance_map.clear();
+ _instance_mapMutex.unlock(); // unlock
+
+ // unload all dynamic libraries
+ _library_mapMutex.lock();
+ std::map<std::string, LocalLibrary>::iterator iL;
+ for (iL=_library_map.begin(); iL != _library_map.end(); iL++)
+ dlclose(iL->second.handle);
+ _library_map.clear();
+ _library_mapMutex.unlock();
+
+ delete _singleton;
+ _singleton = NULL;
}
void LocalContainer::unregisterComponentInstance(CppComponent * C)
{
- _instance_mapMutex.lock(); // lock to be alone
- _instance_map.erase(C->getCompoName());
- _instance_mapMutex.unlock(); // unlock
+ _instance_mapMutex.lock(); // lock to be alone
+ _instance_map.erase(C->getCompoName());
+ _instance_mapMutex.unlock(); // unlock
}
inline void toupper (std::string & s)
{
- transform (s.begin (), s.end (), s.begin (), (int(*)(int)) toupper);
+ transform (s.begin (), s.end (), s.begin (), (int(*)(int)) toupper);
}
LocalLibrary LocalContainer::loadComponentLibrary(const std::string & aCompName, const char * prefix, bool forcedLoad)
public:
CppContainer();
virtual ~CppContainer();
- bool isAlreadyStarted(const ComponentInstance *inst) const;
- void start(const ComponentInstance *inst) throw (YACS::Exception);
- std::string getPlacementId(const ComponentInstance *inst) const;
- std::string getFullPlacementId(const ComponentInstance *inst) const;
+ bool isAlreadyStarted(const Task *askingNode) const;
+ void start(const Task *askingNode) throw (YACS::Exception);
+ void shutdown(int level);
+ std::string getPlacementId(const Task *askingNode) const;
+ std::string getFullPlacementId(const Task *askingNode) const;
YACS::ENGINE::Container *clone() const;
Container *cloneAlways() const;
void lock();
{
YACSTRACE(1,"+++++++++++++++++ DistributedPythonNode::execute: " << getName() << " " << getFname() << " +++++++++++++++++" );
{
- Engines::Container_var objContainer=((SalomeContainer*)_container)->getContainerPtr(0);
+ Engines::Container_var objContainer=((SalomeContainer*)_container)->getContainerPtr(this);
Engines::PyNode_var pn=objContainer->createPyNode(getName().c_str(),getScript().c_str());
//////
int pos=0;
DEBTRACE( "---------------PyNode::loadRemote function---------------" );
if(_container)
{
- if(!_container->isAlreadyStarted(0))
+ if(!_container->isAlreadyStarted(this))
{
try
{
- _container->start(0);
+ _container->start(this);
}
catch(Exception& e)
{
throw Exception(what);
}
- Engines::Container_var objContainer=((SalomeContainer*)_container)->getContainerPtr(0);
+ Engines::Container_var objContainer=((SalomeContainer*)_container)->getContainerPtr(this);
try
{
std::string msg;
try
{
- Engines::Container_var objContainer=((SalomeContainer*)_container)->getContainerPtr(0);
+ Engines::Container_var objContainer=((SalomeContainer*)_container)->getContainerPtr(this);
CORBA::String_var logname = objContainer->logfilename();
DEBTRACE(logname);
msg=logname;
DEBTRACE( "---------------PyfuncNode::loadRemote function---------------" );
if(_container)
{
- if(!_container->isAlreadyStarted(0))
+ if(!_container->isAlreadyStarted(this))
{
try
{
- _container->start(0);
+ _container->start(this);
}
catch(Exception& e)
{
throw Exception(what);
}
- Engines::Container_var objContainer=((SalomeContainer*)_container)->getContainerPtr(0);
+ Engines::Container_var objContainer=((SalomeContainer*)_container)->getContainerPtr(this);
try
{
_pynode = objContainer->createPyNode(getName().c_str(),getScript().c_str());
std::string msg;
try
{
- Engines::Container_var objContainer=((SalomeContainer*)_container)->getContainerPtr(0);
+ Engines::Container_var objContainer=((SalomeContainer*)_container)->getContainerPtr(this);
CORBA::String_var logname = objContainer->logfilename();
DEBTRACE(logname);
msg=logname;
#include "SalomeContainer.hxx"
#include "CppContainer.hxx"
+#include "SalomeHPContainer.hxx"
//Nodes
#include "PythonNode.hxx"
{
if(kind == "" || kind == SalomeComponent::KIND)
return new SalomeContainer;
+ if(kind==SalomeHPContainer::KIND)
+ return new SalomeHPContainer;
else if (kind == CppComponent::KIND)
return new CppContainer;
std::string msg="Container kind ("+kind+") unknown";
}
//! Unload the component
-void SalomeComponent::unload(ServiceNode *askingNode)
+void SalomeComponent::unload(Task *askingNode)
{
//Not implemented
std::cerr << "SalomeComponent::unload : not implemented " << std::endl;
}
//! Is the component instance already loaded ?
-bool SalomeComponent::isLoaded(ServiceNode *askingNode)
+bool SalomeComponent::isLoaded(Task *askingNode) const
{
if(CORBA::is_nil(_objComponent))
return false;
#ifdef SALOME_KERNEL
//! Load the component
-void SalomeComponent::load(ServiceNode *askingNode)
+void SalomeComponent::load(Task *askingNode)
{
if(_container)
{
_objComponent=LCC.LoadComponent(params,_compoName.c_str());
}
#else
-void SalomeComponent::load(ServiceNode *askingNode)
+void SalomeComponent::load(Task *askingNode)
{
throw Exception("YACS has been built without SALOME support");
}
{
namespace ENGINE
{
- class ServiceNode;
-
/*! \brief Class for Salome component instance
*
*
SalomeComponent(const std::string& name);
SalomeComponent(const SalomeComponent& other);
virtual ~SalomeComponent();
- virtual void load(ServiceNode *askingNode);
- virtual void unload(ServiceNode *askingNode);
- virtual bool isLoaded(ServiceNode *askingNode);
+ virtual void load(Task *askingNode);
+ virtual void unload(Task *askingNode);
+ virtual bool isLoaded(Task *askingNode) const;
virtual void setContainer(Container *cont);
virtual ServiceNode* createNode(const std::string& name);
virtual ComponentInstance* clone() const;
}
SalomeContainer::SalomeContainer(const SalomeContainer& other)
-: Container(other),
+: Container(other),_componentNames(other._componentNames),
_launchModeType(other._launchModeType->deepCpyOnlyStaticInfo()),
_shutdownLevel(other._shutdownLevel),
_sct(other._sct)
/*!
* \param inst the component instance to load
*/
-CORBA::Object_ptr SalomeContainer::loadComponent(ServiceNode *inst)
+CORBA::Object_ptr SalomeContainer::loadComponent(Task *askingNode)
{
- return SalomeContainerTools::LoadComponent(_launchModeType,this,inst->getComponent());
+ return SalomeContainerTools::LoadComponent(_launchModeType,this,askingNode);
}
//! Get the container placement id for a component instance
* \param inst the component instance
* \return the placement id
*/
-std::string SalomeContainer::getPlacementId(const ComponentInstance *inst) const
+std::string SalomeContainer::getPlacementId(const Task *askingNode) const
{
- return SalomeContainerTools::GetPlacementId(_launchModeType,this,inst);
+ return SalomeContainerTools::GetPlacementId(_launchModeType,this,askingNode);
}
//! Get the container full path for a component instance
* \param inst the component instance
* \return the full placement id
*/
-std::string SalomeContainer::getFullPlacementId(const ComponentInstance *inst) const
+std::string SalomeContainer::getFullPlacementId(const Task *askingNode) const
{
- return SalomeContainerTools::GetFullPlacementId(_launchModeType,this,inst);
+ return SalomeContainerTools::GetFullPlacementId(_launchModeType,this,askingNode);
}
//! Check if the component instance container is already started
* \param inst the component instance
* \return true, if the container is already started, else false
*/
-bool SalomeContainer::isAlreadyStarted(const ComponentInstance *inst) const
+bool SalomeContainer::isAlreadyStarted(const Task *askingNode) const
{
- return _launchModeType->isAlreadyStarted(inst);
+ return _launchModeType->isAlreadyStarted(askingNode);
}
-Engines::Container_ptr SalomeContainer::getContainerPtr(const ComponentInstance *inst) const
+Engines::Container_ptr SalomeContainer::getContainerPtr(const Task *askingNode) const
{
- return Engines::Container::_duplicate(_launchModeType->getContainer(inst));
+ return Engines::Container::_duplicate(_launchModeType->getContainer(askingNode));
}
//! Start a salome container (true salome container not yacs one) with given ContainerParameters (_params)
/*!
* \param inst the component instance
*/
-void SalomeContainer::start(const ComponentInstance *inst) throw(YACS::Exception)
+void SalomeContainer::start(const Task *askingNode) throw(YACS::Exception)
{
- SalomeContainerTools::Start(_componentNames,_launchModeType,_sct,_shutdownLevel,this,inst);
+ SalomeContainerTools::Start(_componentNames,_launchModeType,_sct,_shutdownLevel,this,askingNode);
}
void SalomeContainer::shutdown(int level)
void lock();
//! For thread safety for concurrent load operation on same Container.
void unLock();
- bool isAlreadyStarted(const ComponentInstance *inst) const;
- Engines::Container_ptr getContainerPtr(const ComponentInstance *inst) const;
- void start(const ComponentInstance *inst) throw (Exception);
+ bool isAlreadyStarted(const Task *askingNode) const;
+ Engines::Container_ptr getContainerPtr(const Task *askingNode) const;
+ void start(const Task *askingNode) throw (Exception);
Container *clone() const;
Container *cloneAlways() const;
- std::string getPlacementId(const ComponentInstance *inst) const;
- std::string getFullPlacementId(const ComponentInstance *inst) const;
+ std::string getPlacementId(const Task *askingNode) const;
+ std::string getFullPlacementId(const Task *askingNode) const;
void checkCapabilityToDealWith(const ComponentInstance *inst) const throw (Exception);
void setProperty(const std::string& name, const std::string& value);
std::string getProperty(const std::string& name) const;
void clearProperties();
void addComponentName(const std::string& name);
void addToResourceList(const std::string& name);
- virtual CORBA::Object_ptr loadComponent(ServiceNode *inst);
+ virtual CORBA::Object_ptr loadComponent(Task *inst);
void shutdown(int level);
// Helper methods
std::map<std::string,std::string> getResourceProperties(const std::string& name) const;
#include "SalomeContainerHelper.hxx"
+#include "ServiceNode.hxx"
#include "YacsTrace.hxx"
#include <sstream>
return new SalomeContainerMonoHelper;
}
-Engines::Container_var SalomeContainerMonoHelper::getContainer(const ComponentInstance *inst) const
+Engines::Container_var SalomeContainerMonoHelper::getContainer(const Task *askingNode) const
{
return _trueCont;
}
-bool SalomeContainerMonoHelper::isAlreadyStarted(const ComponentInstance *inst) const
+bool SalomeContainerMonoHelper::isAlreadyStarted(const Task *askingNode) const
{
if(CORBA::is_nil(_trueCont))
return false;
return true;
}
-void SalomeContainerMonoHelper::setContainer(const ComponentInstance *inst, Engines::Container_var cont)
+void SalomeContainerMonoHelper::setContainer(const Task *askingNode, Engines::Container_var cont)
{
_trueCont=cont;
#ifdef REFCNT
return new SalomeContainerMultiHelper;
}
-Engines::Container_var SalomeContainerMultiHelper::getContainer(const ComponentInstance *inst) const
+Engines::Container_var SalomeContainerMultiHelper::getContainer(const Task *askingNode) const
{
+ 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;
return Engines::Container::_nil();
}
-bool SalomeContainerMultiHelper::isAlreadyStarted(const ComponentInstance *inst) const
+bool SalomeContainerMultiHelper::isAlreadyStarted(const Task *askingNode) const
{
+ const ComponentInstance *inst(askingNode?askingNode->getComponent():0);
if(_trueContainers.count(inst)==0)
return false;
else
return true;
}
-void SalomeContainerMultiHelper::setContainer(const ComponentInstance *inst, Engines::Container_var cont)
+void SalomeContainerMultiHelper::setContainer(const Task *askingNode, Engines::Container_var cont)
{
+ const ComponentInstance *inst(askingNode?askingNode->getComponent():0);
_trueContainers[inst]=cont;
#ifdef REFCNT
std::map<const ComponentInstance *, Engines::Container_var >::const_iterator it;
{
namespace ENGINE
{
+ class Task;
class ComponentInstance;
class SalomeContainerHelper
public:
virtual std::string getType() const = 0;
virtual SalomeContainerHelper *deepCpyOnlyStaticInfo() const = 0;
- virtual Engines::Container_var getContainer(const ComponentInstance *inst) const = 0;
- virtual bool isAlreadyStarted(const ComponentInstance *inst) const = 0;
- virtual void setContainer(const ComponentInstance *inst, Engines::Container_var cont) = 0;
+ virtual Engines::Container_var getContainer(const Task *askingNode) const = 0;
+ virtual bool isAlreadyStarted(const Task *askingNode) const = 0;
+ virtual void setContainer(const Task *askingNode, Engines::Container_var cont) = 0;
virtual void shutdown() = 0;
virtual ~SalomeContainerHelper();
};
SalomeContainerMonoHelper();
std::string getType() const;
SalomeContainerMonoHelper *deepCpyOnlyStaticInfo() const;
- Engines::Container_var getContainer(const ComponentInstance *inst) const;
- bool isAlreadyStarted(const ComponentInstance *inst) const;
- void setContainer(const ComponentInstance *inst, Engines::Container_var cont);
+ Engines::Container_var getContainer(const Task *askingNode) const;
+ bool isAlreadyStarted(const Task *askingNode) const;
+ void setContainer(const Task *askingNode, Engines::Container_var cont);
void shutdown();
~SalomeContainerMonoHelper();
public:
public:
std::string getType() const;
SalomeContainerMultiHelper *deepCpyOnlyStaticInfo() const;
- Engines::Container_var getContainer(const ComponentInstance *inst) const;
- bool isAlreadyStarted(const ComponentInstance *inst) const;
- void setContainer(const ComponentInstance *inst, Engines::Container_var cont);
+ Engines::Container_var getContainer(const Task *askingNode) const;
+ bool isAlreadyStarted(const Task *askingNode) const;
+ void setContainer(const Task *askingNode, Engines::Container_var cont);
void shutdown();
~SalomeContainerMultiHelper();
public:
#include "YacsTrace.hxx"
#include "Proc.hxx"
+#include "ServiceNode.hxx"
#include "ComponentInstance.hxx"
#include "SalomeContainerHelper.hxx"
#include "RuntimeSALOME.hxx"
* \param [in] compoNames
* \param [in,out] shutdownLevel
*/
-void SalomeContainerTools::Start(const std::vector<std::string>& compoNames, SalomeContainerHelper *schelp, SalomeContainerTools& sct, int& shutdownLevel, const Container *cont, const ComponentInstance *inst)
+void SalomeContainerTools::Start(const std::vector<std::string>& compoNames, SalomeContainerHelper *schelp, SalomeContainerTools& sct, int& shutdownLevel, const Container *cont, const Task *askingNode)
{
CORBA::ORB_ptr orb(getSALOMERuntime()->getOrb());
SALOME_NamingService ns;
if(CORBA::is_nil(trueCont))
throw Exception("SalomeContainer::start : Unable to launch container in Salome. Check your CatalogResources.xml file");
- schelp->setContainer(inst,trueCont);
+ schelp->setContainer(askingNode,trueCont);
CORBA::String_var containerName(trueCont->name()),hostName(trueCont->getHostName());
std::cerr << "SalomeContainer launched : " << containerName << " " << hostName << " " << trueCont->getPID() << std::endl;
}
-CORBA::Object_ptr SalomeContainerTools::LoadComponent(SalomeContainerHelper *launchModeType, Container *cont, ComponentInstance *inst)
+CORBA::Object_ptr SalomeContainerTools::LoadComponent(SalomeContainerHelper *launchModeType, Container *cont, Task *askingNode)
{
DEBTRACE("SalomeContainer::loadComponent ");
cont->lock();//To be sure
- if(!cont->isAlreadyStarted(inst))
+ const ComponentInstance *inst(askingNode?askingNode->getComponent():0);
+ if(!cont->isAlreadyStarted(askingNode))
{
try
{
- cont->start(inst);
+ cont->start(askingNode);
}
catch(Exception& e)
{
CORBA::Object_ptr objComponent=CORBA::Object::_nil();
std::string compoName(inst->getCompoName());
const char* componentName=compoName.c_str();
- Engines::Container_var container(launchModeType->getContainer(inst));
+ Engines::Container_var container(launchModeType->getContainer(askingNode));
char* reason;
return objComponent;
}
-std::string SalomeContainerTools::GetPlacementId(SalomeContainerHelper *launchModeType, const Container *cont, const ComponentInstance *inst)
+std::string SalomeContainerTools::GetPlacementId(const SalomeContainerHelper *launchModeType, const Container *cont, const Task *askingNode)
{
- if(cont->isAlreadyStarted(inst))
+ if(cont->isAlreadyStarted(askingNode))
{
- Engines::Container_var container(launchModeType->getContainer(inst));
+ Engines::Container_var container(launchModeType->getContainer(askingNode));
const char *what="/";
CORBA::String_var corbaStr(container->name());
std::string ret(corbaStr);
return "Not placed yet !!!";
}
-std::string SalomeContainerTools::GetFullPlacementId(SalomeContainerHelper *launchModeType, const Container *cont, const ComponentInstance *inst)
+std::string SalomeContainerTools::GetFullPlacementId(const SalomeContainerHelper *launchModeType, const Container *cont, const Task *askingNode)
{
- if(cont->isAlreadyStarted(inst))
+ if(cont->isAlreadyStarted(askingNode))
{
- Engines::Container_var container(launchModeType->getContainer(inst));
+ Engines::Container_var container(launchModeType->getContainer(askingNode));
try
{
CORBA::String_var corbaStr(container->name());
{
namespace ENGINE
{
+ class Task;
class Container;
class ComponentInstance;
class SalomeContainerHelper;
std::string getHostName() const;
Engines::ContainerParameters getParameters() const { return _params; }
public:
- static void Start(const std::vector<std::string>& compoNames, SalomeContainerHelper *schelp, SalomeContainerTools& sct, int& shutdownLevel, const Container *cont, const ComponentInstance *inst);
- static CORBA::Object_ptr LoadComponent(SalomeContainerHelper *launchModeType, Container *cont, ComponentInstance *inst);
- static std::string GetPlacementId(SalomeContainerHelper *launchModeType, const Container *cont, const ComponentInstance *inst);
- static std::string GetFullPlacementId(SalomeContainerHelper *launchModeType, const Container *cont, const ComponentInstance *inst);
+ static void Start(const std::vector<std::string>& compoNames, SalomeContainerHelper *schelp, SalomeContainerTools& sct, int& shutdownLevel, const Container *cont, const Task *askingNode);
+ static CORBA::Object_ptr LoadComponent(SalomeContainerHelper *launchModeType, Container *cont, Task *askingNode);
+ static std::string GetPlacementId(const SalomeContainerHelper *launchModeType, const Container *cont, const Task *askingNode);
+ static std::string GetFullPlacementId(const SalomeContainerHelper *launchModeType, const Container *cont, const Task *askingNode);
protected:
std::map<std::string,std::string> _propertyMap;
Engines::ContainerParameters _params;
//
#include "SalomeHPContainer.hxx"
+#include "SalomeComponent.hxx"
+
+#include <algorithm>
using namespace YACS::ENGINE;
+const char SalomeHPContainer::KIND[]="HPSalome";
+
SalomeHPContainer::SalomeHPContainer():_shutdownLevel(999)
{
}
-SalomeHPContainer::SalomeHPContainer(const SalomeHPContainer& other):_shutdownLevel(999)
+SalomeHPContainer::SalomeHPContainer(const SalomeHPContainer& other):_componentNames(other._componentNames),_shutdownLevel(999),_sct(other._sct)
{
}
_launchModeType.resize(sz);
}
+std::size_t SalomeHPContainer::getNumberOfFreePlace() const
+{
+ return _launchModeType.getNumberOfFreePlace();
+}
+
+void SalomeHPContainer::allocateFor(const std::vector<const Task *>& nodes)
+{
+ _launchModeType.allocateFor(nodes);
+}
+
+void SalomeHPContainer::release(Task *node)
+{
+ _launchModeType.release(node);
+}
+
SalomeHPContainer::~SalomeHPContainer()
{
}
+
+void SalomeHPContainer::lock()
+{
+ _mutex.lock();
+}
+
+void SalomeHPContainer::unLock()
+{
+ _mutex.unlock();
+}
+
+bool SalomeHPContainer::isAlreadyStarted(const Task *askingNode) const
+{
+ const SalomeContainerMonoHelper& helper(_launchModeType.getHelperOfTask(askingNode));
+ return helper.isAlreadyStarted(askingNode);
+}
+
+void SalomeHPContainer::start(const Task *askingNode) throw(Exception)
+{
+ SalomeContainerMonoHelper& helper(_launchModeType.getHelperOfTask(askingNode));
+ SalomeContainerTools::Start(_componentNames,&helper,_sct,_shutdownLevel,this,askingNode);
+}
+
+void SalomeHPContainer::shutdown(int level)
+{
+ if(level < _shutdownLevel)
+ return;
+ _shutdownLevel=999;
+ for(std::size_t i=0;_launchModeType.size();i++)
+ {
+ SalomeContainerMonoHelper& helper(_launchModeType.at(i));
+ helper.shutdown();
+ }
+}
+
+std::string SalomeHPContainer::getPlacementId(const Task *askingNode) const
+{
+ const SalomeContainerMonoHelper& helper(_launchModeType.getHelperOfTask(askingNode));
+ return SalomeContainerTools::GetPlacementId(&helper,this,askingNode);
+}
+
+std::string SalomeHPContainer::getFullPlacementId(const Task *askingNode) const
+{
+ const SalomeContainerMonoHelper& helper(_launchModeType.getHelperOfTask(askingNode));
+ return SalomeContainerTools::GetFullPlacementId(&helper,this,askingNode);
+}
+
+/*!
+ * It is not a bug here ! clone for homogeneous container is not supposed to be copied !
+ */
+Container *SalomeHPContainer::clone() const
+{
+ incrRef();
+ return const_cast<SalomeHPContainer*>(this);
+}
+
+Container *SalomeHPContainer::cloneAlways() const
+{
+ return new SalomeHPContainer(*this);
+}
+
+void SalomeHPContainer::setProperty(const std::string& name,const std::string& value)
+{
+ _sct.setProperty(name,value);
+}
+
+std::string SalomeHPContainer::getProperty(const std::string& name) const
+{
+ return _sct.getProperty(name);
+}
+
+void SalomeHPContainer::clearProperties()
+{
+ _sct.clearProperties();
+}
+
+std::map<std::string,std::string> SalomeHPContainer::getProperties() const
+{
+ return _sct.getProperties();
+}
+
+std::map<std::string,std::string> SalomeHPContainer::getResourceProperties(const std::string& name) const
+{
+ return _sct.getResourceProperties(name);
+}
+
+void SalomeHPContainer::checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception)
+{
+ if(inst->getKind()!=SalomeComponent::KIND)
+ throw Exception("SalomeHPContainer::checkCapabilityToDealWith : SalomeContainer is not able to deal with this type of ComponentInstance.");
+}
#include "HomogeneousPoolContainer.hxx"
#include "SalomeContainerHelper.hxx"
#include "SalomeContainerTools.hxx"
+#include "SalomeHPContainerTools.hxx"
#include "Mutex.hxx"
#include <string>
#include <vector>
+#include <map>
#include <SALOMEconfig.h>
#include CORBA_CLIENT_HEADER(SALOME_Component)
#include CORBA_CLIENT_HEADER(SALOME_ContainerManager)
{
namespace ENGINE
{
+ class Task;
class SalomeComponent;
class YACSRUNTIMESALOME_EXPORT SalomeHPContainer : public HomogeneousPoolContainer
public:
SalomeHPContainer();
SalomeHPContainer(const SalomeHPContainer& other);
+ //HP specific part
void setSizeOfPool(int sz);
+ std::size_t getNumberOfFreePlace() const;
+ void allocateFor(const std::vector<const Task *>& nodes);
+ void release(Task *node);
+ //! For thread safety for concurrent load operation on same Container.
+ void lock();
+ //! For thread safety for concurrent load operation on same Container.
+ void unLock();
+ //
+ bool isAlreadyStarted(const Task *askingNode) const;
+ void start(const Task *askingNode) throw(Exception);
+ void shutdown(int level);
+ std::string getPlacementId(const Task *askingNode) const;
+ std::string getFullPlacementId(const Task *askingNode) const;
+ Container *clone() const;
+ Container *cloneAlways() const;
+ void setProperty(const std::string& name,const std::string& value);
+ std::string getProperty(const std::string& name) const;
+ void clearProperties();
+ std::map<std::string,std::string> getProperties() const;
+ std::map<std::string,std::string> getResourceProperties(const std::string& name) const;
+ void checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception);
+ public:
+ static const char KIND[];
protected:
#ifndef SWIG
~SalomeHPContainer();
#endif
protected:
- YACS::BASES::Mutex _mutex;
- std::vector<std::string> _componentNames;
- std::vector<SalomeContainerMonoHelper> _launchModeType;
int _shutdownLevel;
SalomeContainerTools _sct;
+ YACS::BASES::Mutex _mutex;
+ std::vector<std::string> _componentNames;
+ //
+ SalomeHPContainerVectOfHelper _launchModeType;
};
}
}
--- /dev/null
+// Copyright (C) 2006-2014 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "SalomeHPContainerTools.hxx"
+#include "Exception.hxx"
+
+#include <algorithm>
+
+using namespace YACS::ENGINE;
+
+void SalomeHPContainerVectOfHelper::resize(std::size_t sz)
+{
+ checkNoCurrentWork();
+ _whichOccupied.resize(sz); std::fill(_whichOccupied.begin(),_whichOccupied.end(),false);
+ _launchModeType.clear(); _launchModeType.resize(sz);
+ _currentlyWorking.clear();
+}
+
+std::size_t SalomeHPContainerVectOfHelper::getNumberOfFreePlace() const
+{
+ return std::count(_whichOccupied.begin(),_whichOccupied.end(),false);
+}
+
+void SalomeHPContainerVectOfHelper::allocateFor(const std::vector<const Task *>& nodes)
+{
+ for(std::vector<const Task *>::const_iterator it=nodes.begin();it!=nodes.end();it++)
+ {
+ if(!(*it))
+ continue;
+ if(_currentlyWorking.find(*it)!=_currentlyWorking.end())
+ throw Exception("Searching to allocate for a ServiceNode instance already declared as allocated !");
+ std::vector<bool>::iterator it2(std::find(_whichOccupied.begin(),_whichOccupied.end(),false));
+ if(it2==_whichOccupied.end())
+ throw Exception("All ressources are already occupied ! You are expected to wait for released resources !");
+ std::size_t pos(std::distance(_whichOccupied.begin(),it2));
+ _currentlyWorking[*it]=pos; _whichOccupied[pos]=true;
+ }
+}
+
+void SalomeHPContainerVectOfHelper::release(const Task *node)
+{
+ if(!node)
+ return ;
+ std::map< const Task *,std::size_t >::iterator it(_currentlyWorking.find(node));
+ if(it==_currentlyWorking.end())
+ throw Exception("Request to release a resource not declared as working !");
+ _whichOccupied[(*it).second]=false;
+ _currentlyWorking.erase(it);
+}
+
+const SalomeContainerMonoHelper& SalomeHPContainerVectOfHelper::getHelperOfTask(const Task *node) const
+{
+ return _launchModeType[locateTask(node)];
+}
+
+SalomeContainerMonoHelper& SalomeHPContainerVectOfHelper::getHelperOfTask(const Task *node)
+{
+ return _launchModeType[locateTask(node)];
+}
+
+std::size_t SalomeHPContainerVectOfHelper::locateTask(const Task *node) const
+{
+ std::map< const Task *,std::size_t >::const_iterator it(_currentlyWorking.find(node));
+ if(it==_currentlyWorking.end())
+ throw Exception("current Node to be located is not marked as launched !");
+ std::size_t ret((*it).second);
+ checkPosInVec(ret);
+ return ret;
+}
+
+void SalomeHPContainerVectOfHelper::checkNoCurrentWork() const
+{
+ for(std::map<const Task *,std::size_t >::const_iterator it=_currentlyWorking.begin();it!=_currentlyWorking.end();it++)
+ if((*it).first)
+ throw Exception("Something wrong a node is still declared to be using the ressource !");
+ for(std::vector<SalomeContainerMonoHelper>::const_iterator it=_launchModeType.begin();it!=_launchModeType.end();it++)
+ if((*it).isAlreadyStarted(0))
+ throw Exception("Some of the containers have be started ! Please shutdown them before !");
+}
+
+void SalomeHPContainerVectOfHelper::checkPosInVec(std::size_t pos) const
+{
+ if(pos<0 || pos>=_launchModeType.size())
+ throw Exception("The task has been found, but its id is not in the correct range ! resize of of container size during run ?");
+}
--- /dev/null
+// Copyright (C) 2006-2014 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef __SALOMEHPCONTAINERTOOLS_HXX__
+#define __SALOMEHPCONTAINERTOOLS_HXX__
+
+#include "YACSRuntimeSALOMEExport.hxx"
+#include "SalomeContainerHelper.hxx"
+
+#include <map>
+#include <vector>
+
+namespace YACS
+{
+ namespace ENGINE
+ {
+ class Task;
+ class SalomeComponent;
+
+ class SalomeHPContainerVectOfHelper
+ {
+ public:
+ std::size_t size() const { return _launchModeType.size(); }
+ void resize(std::size_t sz);
+ std::size_t getNumberOfFreePlace() const;
+ void allocateFor(const std::vector<const Task *>& nodes);
+ void release(const Task *node);
+ const SalomeContainerMonoHelper& at(std::size_t pos) const { checkPosInVec(pos); return _launchModeType[pos]; }
+ SalomeContainerMonoHelper& at(std::size_t pos) { checkPosInVec(pos); return _launchModeType[pos]; }
+ const SalomeContainerMonoHelper& getHelperOfTask(const Task *node) const;
+ SalomeContainerMonoHelper& getHelperOfTask(const Task *node);
+ private:
+ std::size_t locateTask(const Task *node) const;
+ void checkNoCurrentWork() const;
+ void checkPosInVec(std::size_t pos) const;
+ private:
+ std::vector<bool> _whichOccupied;
+ std::vector<SalomeContainerMonoHelper> _launchModeType;
+ std::map<const Task *,std::size_t > _currentlyWorking;
+ };
+ }
+}
+
+#endif
{
}
-void SalomePythonComponent::load(ServiceNode *askingNode)
+void SalomePythonComponent::load(Task *askingNode)
{
if(_container)
{
- _container->start(this);
+ _container->start(askingNode);
return;
}
//This component has no specified container : use default container policy
//throw Exception("SalomePythonComponent::load : no container specified !!! To be implemented in executor to allocate default a Container in case of presenceOfDefaultContainer.");
}
-void SalomePythonComponent::unload(ServiceNode *askingNode)
+void SalomePythonComponent::unload(Task *askingNode)
{
}
-bool SalomePythonComponent::isLoaded(ServiceNode *askingNode)
+bool SalomePythonComponent::isLoaded(Task *askingNode) const
{
if(!_container)
return false;
else
- return _container->isAlreadyStarted(this);
+ return _container->isAlreadyStarted(askingNode);
}
std::string SalomePythonComponent::getKind() const
return stream.str();
}
-std::string SalomePythonComponent::getStringValueToExportInInterp() const
+std::string SalomePythonComponent::getStringValueToExportInInterp(const Task *askingNode) const
{
if(!_container)
return "localhost/FactoryServer";
else
- return _container->getPlacementId(this);
+ return _container->getPlacementId(askingNode);
}
SalomePythonComponent(const SalomePythonComponent& other);
std::string getPlacementId() const;
virtual ~SalomePythonComponent();
- virtual void load(ServiceNode *askingNode);
- virtual void unload(ServiceNode *askingNode);
- virtual bool isLoaded(ServiceNode *askingNode);
+ virtual void load(Task *askingNode);
+ virtual void unload(Task *askingNode);
+ virtual bool isLoaded(Task *askingNode) const;
virtual std::string getKind() const;
virtual ComponentInstance* clone() const;
virtual std::string getFileRepr() const;
virtual ServiceNode *createNode(const std::string &name);
//! The specific method that justified SalomePythonComponent class.
- std::string getStringValueToExportInInterp() const;
+ std::string getStringValueToExportInInterp(const Task *askingNode) const;
public:
unsigned _cntForRepr;
static unsigned _cntForReprS;
ServiceInlineNode::load();
cerr << "---------------SalomePythonNode::load function---------------" << endl;
list<OutputPort *>::iterator iter;
- string value2Export=((SalomePythonComponent*)_component)->getStringValueToExportInInterp();
+ string value2Export=((SalomePythonComponent*)_component)->getStringValueToExportInInterp(this);
PyObject* ob=PyString_FromString(value2Export.c_str());
PyDict_SetItemString(_context,PLACEMENT_VAR_NAME_IN_INTERP,ob);
for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++)
%{
#include "SalomeContainer.hxx"
+#include "SalomeHPContainer.hxx"
#include "RuntimeSALOME.hxx"
#include "SALOMEDispatcher.hxx"
#include "SalomeProc.hxx"
%include <YACSRuntimeSALOMEExport.hxx>
%include "SalomeContainer.hxx"
+%include "SalomeHPContainer.hxx"
%include "RuntimeSALOME.hxx"
%include "SALOMEDispatcher.hxx"
%include "SalomeProc.hxx"
