You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
127 lines
4.6 KiB
127 lines
4.6 KiB
#include "PitySwarm.hh"
|
|
#include "PityModel.hh"
|
|
#include "PityPerspective.hh"
|
|
#include "PityUnit.hh"
|
|
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <functional>
|
|
#include <memory>
|
|
#include <stdlib.h>
|
|
|
|
namespace pEp {
|
|
namespace PityTest11 {
|
|
bool PitySwarm::debug_log_enabled = false;
|
|
|
|
PitySwarm::PitySwarm(const std::string& name, PityModel& model) :
|
|
_model{ model }, _swarmUnit{ name, nullptr, nullptr, PityUnit<>::ExecutionMode::PROCESS_SEQUENTIAL }
|
|
{
|
|
logger_debug.set_instancename(name);
|
|
pEpLogClass("called");
|
|
|
|
for (auto n : _model.nodes()) {
|
|
TestUnit* tmp = &_swarmUnit.addNew<TestUnit>(
|
|
n->getName(),
|
|
std::bind(
|
|
&PitySwarm::_init_process,
|
|
this,
|
|
std::placeholders::_1,
|
|
std::placeholders::_2),
|
|
nullptr,
|
|
TestUnit::ExecutionMode::PROCESS_PARALLEL);
|
|
// By value copies the context into the TestUnit
|
|
tmp->setContext(_createPerspective(_model, n->getNr()));
|
|
_nodeUnits.insert(std::pair<int, TestUnit*>(n->getNr(), tmp));
|
|
}
|
|
}
|
|
|
|
PitySwarm::PitySwarm(const PitySwarm& rhs, const std::string& new_name) :
|
|
_model{ rhs._model }, _swarmUnit{ new_name }
|
|
{
|
|
logger_debug.set_instancename(new_name);
|
|
_swarmUnit = TestUnit(rhs._swarmUnit);
|
|
// TODO: Hack for some reason ExecMode is getting copied,
|
|
// Copy of Swarm is _b0rken
|
|
_swarmUnit.setExecMode(PityUnit<>::ExecutionMode::PROCESS_SEQUENTIAL);
|
|
_swarmUnit.setName(new_name);
|
|
for (auto n : rhs._nodeUnits) {
|
|
TestUnit* tmp = &_swarmUnit.addCopy(TestUnit (*n.second));
|
|
_nodeUnits.insert(std::pair<int, TestUnit*>(n.first, tmp));
|
|
}
|
|
}
|
|
|
|
PitySwarm::TestUnit& PitySwarm::getSwarmUnit()
|
|
{
|
|
return _swarmUnit;
|
|
}
|
|
|
|
PitySwarm::TestUnit& PitySwarm::getLeafUnit(int nodeNr)
|
|
{
|
|
TestUnit* ret = nullptr;
|
|
TestUnit* current = _nodeUnits.at(nodeNr);
|
|
do {
|
|
if (current == nullptr) {
|
|
throw std::runtime_error("bad fatal cast in the ugly hack");
|
|
}
|
|
if (current->getChildCount() == 0) {
|
|
ret = current;
|
|
} else {
|
|
current = dynamic_cast<TestUnit*>(
|
|
&(current->getChildRefs().begin()->second)); // random child
|
|
}
|
|
} while (ret == nullptr);
|
|
return *ret;
|
|
}
|
|
|
|
PitySwarm::TestUnit& PitySwarm::addTestUnit(int nodeNr, const TestUnit& unit)
|
|
{
|
|
TestUnit& ret = getLeafUnit(nodeNr).addCopy(std::move(unit));
|
|
return ret;
|
|
}
|
|
|
|
void PitySwarm::run()
|
|
{
|
|
_swarmUnit.run();
|
|
}
|
|
|
|
// The perspective currently is completely defined by specifying a node,
|
|
// since there is a 1-1 node/ident relationship currently
|
|
PityPerspective PitySwarm::_createPerspective(const PityModel& model, int node_nr)
|
|
{
|
|
PityPerspective psp{ model };
|
|
psp.own_name = model.nodeNr(node_nr)->getName();
|
|
|
|
// Default partner is next node, its a circle
|
|
int partner_node_index = (node_nr + 1) % model.nodes().size();
|
|
psp.cpt_name = model.nodes().at(partner_node_index)->getName();
|
|
|
|
// Create peers, everyone but me
|
|
auto nodes = model.nodes();
|
|
for (int i = 0; i < nodes.size(); i++) {
|
|
if (i != node_nr) {
|
|
psp.peers.push_back(nodes.at(i)->getName());
|
|
}
|
|
}
|
|
|
|
// Groups
|
|
int grp_mod_node_nr = 0;
|
|
if (grp_mod_node_nr == node_nr) {
|
|
Test::Utils::Group grp1 = Test::Utils::Group{};
|
|
grp1.name = "grp_" + psp.own_name;
|
|
grp1.moderator = psp.own_name;
|
|
grp1.members = psp.peers;
|
|
psp.own_groups.push_back(grp1);
|
|
}
|
|
return psp;
|
|
}
|
|
|
|
int PitySwarm::_init_process(TestUnit& unit, PityPerspective* ctx)
|
|
{
|
|
// This should not be needed
|
|
// std::cout << "Node _initProcUnitNrRecurse, setting $HOME" << std::endl;
|
|
// std::string home = unit.processDir();
|
|
// setenv("HOME", home.c_str(), true);
|
|
return 0;
|
|
}
|
|
} // namespace PityTest11
|
|
} // namespace pEp
|
|
|