heck
4 years ago
6 changed files with 530 additions and 518 deletions
@ -0,0 +1,360 @@ |
|||||
|
#include "pEpTestTree.hh" |
||||
|
#include "../../../src/std_utils.hh" |
||||
|
#include "../../framework/utils.hh" |
||||
|
#include <iostream> |
||||
|
#include <unistd.h> |
||||
|
#include <cstdlib> |
||||
|
#include <sys/stat.h> |
||||
|
#include <functional> |
||||
|
#include <algorithm> |
||||
|
#include <sstream> |
||||
|
|
||||
|
|
||||
|
using namespace std; |
||||
|
using namespace pEp::Adapter; |
||||
|
using namespace pEp::Utils; |
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace Test { |
||||
|
string pEpTestTree::_data_root = "./peptest"; |
||||
|
bool pEpTestTree::debug_log_enabled = false; |
||||
|
|
||||
|
// PUBIC CONCSTRUCTORS / FACTORY -----------------------------------------------------------
|
||||
|
// static
|
||||
|
pEpTestTree pEpTestTree::createRootNode( |
||||
|
pEpTestModel& model, |
||||
|
const string& name, |
||||
|
const NodeFunc& test_func, |
||||
|
ExecutionMode exec_mode) |
||||
|
{ |
||||
|
pEpTestTree ret(nullptr, &model, name, test_func, exec_mode); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
// static
|
||||
|
pEpTestTree pEpTestTree::createChildNode( |
||||
|
pEpTestTree& parent, |
||||
|
const string& name, |
||||
|
const NodeFunc& test_func, |
||||
|
ExecutionMode exec_mode) |
||||
|
{ |
||||
|
pEpTestTree ret(&parent, nullptr, name, test_func, exec_mode); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
string pEpTestTree::getNodeName() const |
||||
|
{ |
||||
|
return _name; |
||||
|
} |
||||
|
|
||||
|
string pEpTestTree::getNodePath() const |
||||
|
{ |
||||
|
pEpLogClass("called"); |
||||
|
string ret; |
||||
|
|
||||
|
if (!_isRootNode()) { |
||||
|
ret = _parent->getNodePath() + "/" + getNodeName(); |
||||
|
} else { |
||||
|
ret = getNodeName(); |
||||
|
} |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
// For:
|
||||
|
// RootNode - "<name>"
|
||||
|
// ProcessNode - ".../<proc>"
|
||||
|
// When Process as dir. parent - ".../<proc>/name"
|
||||
|
// When no process as dir. parent - ".../<proc>/.../name"
|
||||
|
std::string pEpTestTree::getNodePathShort() const |
||||
|
{ |
||||
|
string ret; |
||||
|
if (_isRootNode()) { |
||||
|
ret = getNodeName(); |
||||
|
} else { |
||||
|
if (_isProcessNode()) { |
||||
|
ret += ".../" + getNodeName(); |
||||
|
} else { |
||||
|
if (&(_getParentingProcessNode()) == (_parent)) { |
||||
|
ret = _getParentingProcessNode().getNodePathShort() + "/" + getNodeName(); |
||||
|
} else { |
||||
|
ret = _getParentingProcessNode().getNodePathShort() + "/.../" + getNodeName(); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
// Inherited (if null see parent recursively)
|
||||
|
pEpTestModel& pEpTestTree::getModel() const |
||||
|
{ |
||||
|
pEpLogClass("called"); |
||||
|
pEpTestModel* ret = nullptr; |
||||
|
if (_model == nullptr) { |
||||
|
ret = &(_parent->getModel()); |
||||
|
} else { |
||||
|
ret = _model; |
||||
|
} |
||||
|
assert(ret != nullptr); |
||||
|
// cant be null because for createChildNode() you have to provide TestNode& instance,
|
||||
|
// and the only other way to get one is by createRootNode() which in turn requires a TestModel&
|
||||
|
return *ret; |
||||
|
} |
||||
|
|
||||
|
// RootNodes have their own data_dir
|
||||
|
// ProcessNodes have their own data_dir inside their RootNote dir (nameclash prossible)
|
||||
|
// All other nodes inherit data_dir from their Root/ProcessNode
|
||||
|
string pEpTestTree::getDataDir() const |
||||
|
{ |
||||
|
pEpLogClass("called"); |
||||
|
string ret; |
||||
|
if (_isRootNode()) { |
||||
|
ret = getDataRoot() + getNodeName() + "/"; |
||||
|
} else { |
||||
|
if (_parent->_exec_mode == ExecutionMode::PROCESS_SERIAL || |
||||
|
_parent->_exec_mode == ExecutionMode::PROCESS_PARALLEL) { |
||||
|
|
||||
|
ret = _parent->getDataDir() + getNodeName(); |
||||
|
} else { |
||||
|
// inherit
|
||||
|
ret = _parent->getDataDir(); |
||||
|
} |
||||
|
} |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
// static
|
||||
|
void pEpTestTree::setDataRoot(const string& dir) |
||||
|
{ |
||||
|
pEpTestTree::_data_root = dir; |
||||
|
} |
||||
|
|
||||
|
// static
|
||||
|
string pEpTestTree::getDataRoot() |
||||
|
{ |
||||
|
return pEpTestTree::_data_root; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void pEpTestTree::run(const pEpTestTree* caller) const |
||||
|
{ |
||||
|
pEpLogClass("called"); |
||||
|
// caller is never nullptr if called by another pEpTestTree
|
||||
|
if (caller == nullptr) { |
||||
|
pEpLog::logH1("Starting pEpTestTree from node: " + getNodePathShort()); |
||||
|
pEpLog::log(to_string()); |
||||
|
} |
||||
|
|
||||
|
pEpLog::logH2( |
||||
|
"[ " + to_string(_exec_mode) + " / " + getNodePathShort() + "]"); |
||||
|
// Execute in fork and wait here until process ends
|
||||
|
if (_exec_mode == ExecutionMode::PROCESS_SERIAL) { // fork
|
||||
|
_executeInFork(bind(&pEpTestTree::_run, this), true); |
||||
|
// Execute in fork and go on, wait for process execution in the end
|
||||
|
} else if (_exec_mode == ExecutionMode::PROCESS_PARALLEL) { |
||||
|
_executeInFork(bind(&pEpTestTree::_run, this), false); |
||||
|
// Execute as normal funciton
|
||||
|
} else if (_exec_mode == ExecutionMode::FUNCTION) { |
||||
|
_run(); |
||||
|
} else if (_exec_mode == ExecutionMode::THREAD_PARALLEL) { |
||||
|
throw invalid_argument(to_string(_exec_mode) + " - not implemented"); |
||||
|
} else if (_exec_mode == ExecutionMode::THREAD_SERIAL) { |
||||
|
throw invalid_argument(to_string(_exec_mode) + " - not implemented"); |
||||
|
} |
||||
|
|
||||
|
if (caller == nullptr) { |
||||
|
_waitChildProcesses(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
string pEpTestTree::to_string(bool recursive, int indent) const |
||||
|
{ |
||||
|
string ret; |
||||
|
stringstream builder; |
||||
|
builder << string(indent, '\t'); |
||||
|
builder << getNodeName(); |
||||
|
builder << "[" << to_string(_exec_mode) << "]"; |
||||
|
builder << endl; |
||||
|
ret = builder.str(); |
||||
|
|
||||
|
if (recursive) { |
||||
|
indent++; |
||||
|
for (const pair<string, const pEpTestTree&> child : _children) { |
||||
|
ret += child.second.to_string(true, indent); |
||||
|
} |
||||
|
indent--; |
||||
|
} |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
string pEpTestTree::to_string(const ExecutionMode& emode) |
||||
|
{ |
||||
|
switch (emode) { |
||||
|
case ExecutionMode::FUNCTION: |
||||
|
return "FUNCTION"; |
||||
|
case ExecutionMode::PROCESS_SERIAL: |
||||
|
return "PROCESS_SERIAL"; |
||||
|
case ExecutionMode::PROCESS_PARALLEL: |
||||
|
return "PROCESS_PARALLEL"; |
||||
|
case ExecutionMode::THREAD_SERIAL: |
||||
|
return "THREAD_SERIAL"; |
||||
|
case ExecutionMode::THREAD_PARALLEL: |
||||
|
return "THREAD_PARALLEL"; |
||||
|
case ExecutionMode::INHERIT: |
||||
|
return "INHERIT"; |
||||
|
default: |
||||
|
return "UNDEFINED EXECUTION MODE"; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
//Well, ok, lets just add some little convenience logging service in here, too
|
||||
|
void pEpTestTree::log(const string& msg) const |
||||
|
{ |
||||
|
stringstream builder; |
||||
|
builder << "["; |
||||
|
builder << std::to_string(getpid()); |
||||
|
builder << " - "; |
||||
|
builder << getNodePathShort(); |
||||
|
builder << "] - "; |
||||
|
builder << msg; |
||||
|
builder << endl; |
||||
|
cout << builder.str(); |
||||
|
} |
||||
|
|
||||
|
// PRIVATE ---------------------------------------------------------------------------------
|
||||
|
|
||||
|
pEpTestTree::pEpTestTree( |
||||
|
pEpTestTree* const parent, |
||||
|
pEpTestModel* model, |
||||
|
const string& name, |
||||
|
const NodeFunc& test_func, |
||||
|
ExecutionMode exec_mode) : |
||||
|
_parent(parent), |
||||
|
_model(model), _name(_normalizeName(name)), _test_func(test_func), _exec_mode(exec_mode) |
||||
|
{ |
||||
|
logger_debug.set_instancename(getNodePath()); |
||||
|
if (!_isRootNode()) { |
||||
|
parent->_addChildNode(*this); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void pEpTestTree::_run() const |
||||
|
{ |
||||
|
if (_test_func) { |
||||
|
_test_func(*this); |
||||
|
} else { |
||||
|
pEpLog::log("No function to execute"); |
||||
|
} |
||||
|
if (!_children.empty()) { |
||||
|
for (const pair<string, pEpTestTree&> child : _children) { |
||||
|
child.second.run(this); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void pEpTestTree::_executeInFork(function<void(void)> func, bool wait_child) const |
||||
|
{ |
||||
|
pid_t pid; |
||||
|
pid = fork(); |
||||
|
if (pid == pid_t(0)) { |
||||
|
func(); |
||||
|
exit(0); |
||||
|
} else if (pid < pid_t(0)) { |
||||
|
throw runtime_error("Error forking"); |
||||
|
} |
||||
|
if (wait_child) { |
||||
|
_waitChildProcesses(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void pEpTestTree::_waitChildProcesses() const |
||||
|
{ |
||||
|
int status; |
||||
|
pid_t pid; |
||||
|
while ((pid = wait(&status)) > 0) { |
||||
|
pEpLog::log( |
||||
|
"process[" + std::to_string((int)pid) + |
||||
|
"] terminated with status: " + std::to_string(status)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void pEpTestTree::_addChildNode(pEpTestTree& node) |
||||
|
{ |
||||
|
_children.insert(pair<string, pEpTestTree&>(node.getNodeName(), node)); |
||||
|
} |
||||
|
|
||||
|
bool pEpTestTree::_isProcessNode() const |
||||
|
{ |
||||
|
bool ret = false; |
||||
|
if (_exec_mode == ExecutionMode::PROCESS_SERIAL || |
||||
|
_exec_mode == ExecutionMode::PROCESS_PARALLEL) { |
||||
|
ret = true; |
||||
|
} |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
bool pEpTestTree::_isRootNode() const |
||||
|
{ |
||||
|
bool ret = false; |
||||
|
if (_parent == nullptr) { |
||||
|
ret = true; |
||||
|
} |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
const pEpTestTree& pEpTestTree::_getRootNode() const |
||||
|
{ |
||||
|
const pEpTestTree* ret = nullptr; |
||||
|
if (!_isRootNode()) { |
||||
|
ret = &(_parent->_getRootNode()); |
||||
|
} else { |
||||
|
ret = this; |
||||
|
} |
||||
|
assert(ret != nullptr); |
||||
|
// cant be null because for createChildNode() you need to provide a TestNode& and
|
||||
|
// the only other way is using createRootNode() which has parent == nullptr
|
||||
|
return *ret; |
||||
|
} |
||||
|
|
||||
|
const pEpTestTree& pEpTestTree::_getParentingProcessNode() const |
||||
|
{ |
||||
|
if (_isRootNode() || _isProcessNode()) { |
||||
|
return *this; |
||||
|
} else { |
||||
|
return _parent->_getParentingProcessNode(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// name is alphanumeric only (everything else will be replaced by an underscore)
|
||||
|
string pEpTestTree::_normalizeName(string name) const |
||||
|
{ |
||||
|
replace_if( |
||||
|
name.begin(), |
||||
|
name.end(), |
||||
|
[](char c) -> bool { return !isalnum(c); }, |
||||
|
'_'); |
||||
|
|
||||
|
return name; |
||||
|
} |
||||
|
|
||||
|
void pEpTestTree::_data_dir_create() |
||||
|
{ |
||||
|
// Utils::dir_create(getDataDir());
|
||||
|
pEpLog::log("creating dir:" + getDataRoot()); |
||||
|
} |
||||
|
|
||||
|
void pEpTestTree::_data_dir_delete() |
||||
|
{ |
||||
|
try { |
||||
|
Utils::path_delete_all(getDataRoot()); |
||||
|
} catch (const exception& e) { |
||||
|
pEpLog::log("DistTest: - could not delete data dir: " + getDataRoot()); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void pEpTestTree::_data_dir_recreate() |
||||
|
{ |
||||
|
_data_dir_delete(); |
||||
|
_data_dir_create(); |
||||
|
}; |
||||
|
} // namespace Test
|
||||
|
} // namespace pEp
|
||||
@ -0,0 +1,118 @@ |
|||||
|
// This file is under GNU General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
#ifndef LIBPEPADAPTER_PEPTEST_PEPTESTTREE_HH |
||||
|
#define LIBPEPADAPTER_PEPTEST_PEPTESTTREE_HH |
||||
|
|
||||
|
#include <string> |
||||
|
#include <functional> |
||||
|
#include <map> |
||||
|
#include "../../../src/pEpLog.hh" |
||||
|
#include "pEpTestModel.hh" |
||||
|
|
||||
|
// Yes, the mem mgmt is purely static on purpose (so far)
|
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace Test { |
||||
|
class pEpTestTree { |
||||
|
public: |
||||
|
using NodeFunc = std::function<void(const pEpTestTree&)>; |
||||
|
|
||||
|
enum class ExecutionMode |
||||
|
{ |
||||
|
FUNCTION, |
||||
|
PROCESS_SERIAL, |
||||
|
PROCESS_PARALLEL, |
||||
|
THREAD_SERIAL, // unimplemented
|
||||
|
THREAD_PARALLEL, // unimplemented
|
||||
|
INHERIT |
||||
|
}; |
||||
|
|
||||
|
// Constructors are private
|
||||
|
pEpTestTree() = delete; |
||||
|
|
||||
|
// Modify
|
||||
|
static pEpTestTree createRootNode( |
||||
|
pEpTestModel& model, |
||||
|
const std::string& name, |
||||
|
const NodeFunc& test_func, |
||||
|
ExecutionMode exec_mode = ExecutionMode::FUNCTION); |
||||
|
|
||||
|
static pEpTestTree createChildNode( |
||||
|
pEpTestTree& parent, |
||||
|
const std::string& name, |
||||
|
const NodeFunc& test_func, |
||||
|
ExecutionMode exec_mode = ExecutionMode::FUNCTION); |
||||
|
|
||||
|
// Read-Only
|
||||
|
std::string getNodeName() const; // name only
|
||||
|
std::string getNodePath() const; // full path (is an ID)
|
||||
|
std::string getNodePathShort() const; // parent process + name
|
||||
|
pEpTestModel& getModel() const; |
||||
|
std::string getDataDir() const; |
||||
|
|
||||
|
// Read-Write
|
||||
|
static void setDataRoot(const std::string& dir); |
||||
|
static std::string getDataRoot(); |
||||
|
|
||||
|
// Main funcs
|
||||
|
void run(const pEpTestTree* caller = nullptr) const; |
||||
|
std::string to_string(bool recursive = true, int indent = 0) const; |
||||
|
static std::string to_string(const ExecutionMode& emode); |
||||
|
|
||||
|
// logging service
|
||||
|
void log(const std::string& msg) const; |
||||
|
|
||||
|
// internal logging
|
||||
|
static bool debug_log_enabled; |
||||
|
Adapter::pEpLog::pEpLogger logger_debug{ "pEpTestTree", debug_log_enabled }; |
||||
|
|
||||
|
private: |
||||
|
// CONSTRUCGTORS
|
||||
|
explicit pEpTestTree( |
||||
|
pEpTestTree* parent, |
||||
|
pEpTestModel* model, |
||||
|
const std::string& name, |
||||
|
const NodeFunc& test_func, |
||||
|
ExecutionMode exec_mode); |
||||
|
|
||||
|
// METHODS
|
||||
|
// Execution
|
||||
|
void _run() const; |
||||
|
void _executeInFork(std::function<void(void)> func, bool wait_child) const; |
||||
|
void _waitChildProcesses() const; |
||||
|
|
||||
|
// Modify
|
||||
|
void _addChildNode(pEpTestTree& node); |
||||
|
|
||||
|
// Query
|
||||
|
bool _isProcessNode() const; |
||||
|
bool _isRootNode() const; |
||||
|
const pEpTestTree& _getRootNode() const; |
||||
|
const pEpTestTree& _getParentingProcessNode() const; |
||||
|
|
||||
|
// Util
|
||||
|
std::string _normalizeName(std::string name) const; |
||||
|
|
||||
|
// TODO
|
||||
|
void _data_dir_delete(); |
||||
|
void _data_dir_create(); |
||||
|
void _data_dir_recreate(); |
||||
|
|
||||
|
// Fields
|
||||
|
const std::string _name; |
||||
|
const pEpTestTree* _parent; //nullptr if RootUnit
|
||||
|
pEpTestModel* _model; //nullptr if inherited
|
||||
|
const NodeFunc& _test_func; |
||||
|
const ExecutionMode _exec_mode; |
||||
|
static std::string _data_root; |
||||
|
|
||||
|
std::map<const std::string, pEpTestTree&> _children; // map to guarantee uniqueness of sibling-names
|
||||
|
|
||||
|
// internal logging
|
||||
|
Adapter::pEpLog::pEpLogger& m4gic_logger_n4me = logger_debug; |
||||
|
}; |
||||
|
}; // namespace Test
|
||||
|
}; // namespace pEp
|
||||
|
|
||||
|
#endif // LIBPEPADAPTER_PEPTEST_PEPTESTTREE_HH
|
||||
@ -1,379 +0,0 @@ |
|||||
#include "pEpTestUnit.hh" |
|
||||
#include "../../../src/std_utils.hh" |
|
||||
#include "../../framework/utils.hh" |
|
||||
#include <iostream> |
|
||||
#include <unistd.h> |
|
||||
#include <cstdlib> |
|
||||
#include <sys/stat.h> |
|
||||
#include <functional> |
|
||||
#include <algorithm> |
|
||||
#include <sstream> |
|
||||
|
|
||||
using namespace std; |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace Test { |
|
||||
bool pEpTestUnit::log_enabled = true; |
|
||||
string pEpTestUnit::data_root = "./peptest"; |
|
||||
pEpTestUnit::ExecutionMode pEpTestUnit::emode_default = pEpTestUnit::ExecutionMode::FUNCTION; |
|
||||
|
|
||||
// RootNode factory
|
|
||||
// static
|
|
||||
pEpTestUnit pEpTestUnit::createRootNode( |
|
||||
pEpTestModel& model, |
|
||||
const std::string& name, |
|
||||
const TestUnitFunction& test_func, |
|
||||
ExecutionMode emode_children) |
|
||||
{ |
|
||||
pEpTestUnit ret(nullptr, &model, name, test_func, emode_children); |
|
||||
return ret; |
|
||||
} |
|
||||
|
|
||||
// ChildNode factory
|
|
||||
// static
|
|
||||
pEpTestUnit pEpTestUnit::createChildNode( |
|
||||
pEpTestUnit& parent, |
|
||||
const std::string& name, |
|
||||
const TestUnitFunction& test_func, |
|
||||
ExecutionMode emode_children) |
|
||||
{ |
|
||||
pEpTestUnit ret(&parent, nullptr, name, test_func, emode_children); |
|
||||
return ret; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
// private
|
|
||||
pEpTestUnit::pEpTestUnit( |
|
||||
pEpTestUnit* const parent, |
|
||||
pEpTestModel* model, |
|
||||
const std::string& name, |
|
||||
const TestUnitFunction& test_func, |
|
||||
ExecutionMode emode_children) : |
|
||||
parent(parent), |
|
||||
model(model), name(normalizeName(name)), test_func(test_func), emode_chld(emode_children) |
|
||||
{ |
|
||||
logger.set_instancename(getFQName()); |
|
||||
if (!isRootNode()) { |
|
||||
parent->addChildNode(*this); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// static
|
|
||||
void pEpTestUnit::setDefaultDataRoot(const std::string& dir) |
|
||||
{ |
|
||||
pEpTestUnit::data_root = dir; |
|
||||
} |
|
||||
|
|
||||
// static
|
|
||||
std::string pEpTestUnit::getDataRoot() |
|
||||
{ |
|
||||
return pEpTestUnit::data_root; |
|
||||
} |
|
||||
|
|
||||
void pEpTestUnit::init(const pEpTestUnit* caller) const |
|
||||
{ |
|
||||
//caller is never nullptr if called from another unit
|
|
||||
if (caller == nullptr) {} |
|
||||
|
|
||||
// for (const pair<string, pEpTestUnit&> elem : testnodes) {
|
|
||||
// string home_dir = evalHomeDir(elem.second);
|
|
||||
// pEpLogClass("creating home dir for '" + elem.second.getName() + "' - " + home_dir); mkdir(home_dir.c_str(), 0770);
|
|
||||
// }
|
|
||||
} |
|
||||
|
|
||||
void pEpTestUnit::addChildNode(pEpTestUnit& node) |
|
||||
{ |
|
||||
children.insert(pair<string, pEpTestUnit&>(node.getName(), node)); |
|
||||
} |
|
||||
|
|
||||
// name is alphanumeric only (everything else will be replaced by an underscore)
|
|
||||
// private
|
|
||||
string pEpTestUnit::normalizeName(string name) const |
|
||||
{ |
|
||||
replace_if( |
|
||||
name.begin(), |
|
||||
name.end(), |
|
||||
[](char c) -> bool { return !isalnum(c); }, |
|
||||
'_'); |
|
||||
|
|
||||
return name; |
|
||||
} |
|
||||
|
|
||||
string pEpTestUnit::getName() const |
|
||||
{ |
|
||||
return name; |
|
||||
} |
|
||||
|
|
||||
// RootNodes have their own data_dir
|
|
||||
// ProcessNodes have their own data_dir inside their RootNote dir (nameclash prossible)
|
|
||||
// All other nodes inherit data_dir from their Root/ProcessNode
|
|
||||
string pEpTestUnit::getDataDir() const |
|
||||
{ |
|
||||
string ret; |
|
||||
if (isRootNode()) { |
|
||||
ret = getDataRoot() + getName() + "/"; |
|
||||
} else { |
|
||||
if (parent->getEffectiveExecutionMode() == ExecutionMode::PROCESS_SERIAL || |
|
||||
parent->getEffectiveExecutionMode() == ExecutionMode::PROCESS_PARALLEL) { |
|
||||
|
|
||||
ret = parent->getDataDir() + getName(); |
|
||||
} else { |
|
||||
// inherit
|
|
||||
ret = parent->getDataDir(); |
|
||||
} |
|
||||
} |
|
||||
return ret; |
|
||||
} |
|
||||
|
|
||||
void pEpTestUnit::run(const pEpTestUnit* caller) |
|
||||
{ |
|
||||
pEpLogClass("called"); |
|
||||
// caller is never nullptr if called by another pEpTestUnit
|
|
||||
if (caller == nullptr) { |
|
||||
pEpLogClass("\n" + to_string()); |
|
||||
} |
|
||||
|
|
||||
if (test_func) { |
|
||||
test_func(*this); |
|
||||
} else { |
|
||||
pEpLogClass("No function to execute"); |
|
||||
} |
|
||||
executeChildren(); |
|
||||
} |
|
||||
|
|
||||
// private
|
|
||||
void pEpTestUnit::executeChildren() const |
|
||||
{ |
|
||||
if (!children.empty()) { |
|
||||
const ExecutionMode& emode = getEffectiveExecutionMode(); |
|
||||
for (const pair<string, pEpTestUnit&> elem : children) { |
|
||||
// Execute in fork and wait here until process ends
|
|
||||
if (emode == ExecutionMode::PROCESS_SERIAL) { // fork
|
|
||||
executeForked(elem.second); |
|
||||
waitChildProcesses(); |
|
||||
// Execute in fork and go on, wait for process execution in the end
|
|
||||
} else if (emode == ExecutionMode::PROCESS_PARALLEL) { |
|
||||
executeForked(elem.second); |
|
||||
// Execute as normal funciton
|
|
||||
} else if (emode == ExecutionMode::FUNCTION) { |
|
||||
elem.second.run(this); |
|
||||
} else if (emode == ExecutionMode::THREAD_PARALLEL) { |
|
||||
throw runtime_error(to_string(emode) + " - not implemented"); |
|
||||
} else if (emode == ExecutionMode::THREAD_SERIAL) { |
|
||||
throw runtime_error(to_string(emode) + " - not implemented"); |
|
||||
} |
|
||||
} |
|
||||
if (emode == ExecutionMode::PROCESS_PARALLEL) { |
|
||||
waitChildProcesses(); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// private
|
|
||||
void pEpTestUnit::executeForked(pEpTestUnit& unit) const |
|
||||
{ |
|
||||
pid_t pid; |
|
||||
pid = fork(); |
|
||||
if (pid == pid_t(0)) { |
|
||||
// setenv("HOME", evalHomeDir().c_str(), 1);
|
|
||||
unit.run(this); |
|
||||
exit(0); |
|
||||
} else if (pid < pid_t(0)) { |
|
||||
pEpLogClass("Error forking"); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// private
|
|
||||
void pEpTestUnit::waitChildProcesses() const |
|
||||
{ |
|
||||
int status; |
|
||||
pid_t pid; |
|
||||
while ((pid = wait(&status)) > 0) { |
|
||||
pEpLogClass( |
|
||||
"process[" + to_string((int)pid) + |
|
||||
"] terminated with status: " + to_string(status)); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// Inherited (if null see parent recursively)
|
|
||||
pEpTestModel& pEpTestUnit::getModel() const |
|
||||
{ |
|
||||
// pEpLogClass("called");
|
|
||||
pEpTestModel* ret = nullptr; |
|
||||
if (model == nullptr) { |
|
||||
ret = &parent->getModel(); |
|
||||
} else { |
|
||||
ret = model; |
|
||||
} |
|
||||
assert(ret != nullptr); |
|
||||
// cant be null because for createChildNode() you have to provide TestNode& instance,
|
|
||||
// and the only other way to get one is by createRootNode() which in turn requires a TestModel&
|
|
||||
return *ret; |
|
||||
} |
|
||||
|
|
||||
const pEpTestUnit& pEpTestUnit::getRoot() const |
|
||||
{ |
|
||||
// pEpLogClass("called");
|
|
||||
const pEpTestUnit* ret = nullptr; |
|
||||
if (!isRootNode()) { |
|
||||
ret = &parent->getRoot(); |
|
||||
} else { |
|
||||
ret = this; |
|
||||
} |
|
||||
assert(ret != nullptr); |
|
||||
// cant be null because for createChildNode() you need to provide a TestNode& and
|
|
||||
// the only other way is using createRootNode() which has parent == nullptr
|
|
||||
return *ret; |
|
||||
} |
|
||||
|
|
||||
string pEpTestUnit::getFQNameNormalized() const |
|
||||
{ |
|
||||
return normalizeName(getFQName()); |
|
||||
} |
|
||||
|
|
||||
string pEpTestUnit::getFQName() const |
|
||||
{ |
|
||||
// pEpLogClass("called");
|
|
||||
string ret; |
|
||||
|
|
||||
if (!isRootNode()) { |
|
||||
ret = parent->getFQName() + "/" + getName(); |
|
||||
} else { |
|
||||
ret = getName(); |
|
||||
} |
|
||||
return ret; |
|
||||
} |
|
||||
|
|
||||
// // A process node is a node that spawns its own process
|
|
||||
// bool pEpTestUnit::isProcessNode() const
|
|
||||
// {
|
|
||||
// bool ret = false;
|
|
||||
// if (isRootNode() ||
|
|
||||
// parent->getEffectiveExecutionMode() == ExecutionMode::PROCESS_PARALLEL ||
|
|
||||
// parent->getEffectiveExecutionMode() == ExecutionMode::PROCESS_SERIAL) {
|
|
||||
// ret = true;
|
|
||||
// }
|
|
||||
// return ret;
|
|
||||
// }
|
|
||||
|
|
||||
bool pEpTestUnit::isRootNode() const |
|
||||
{ |
|
||||
bool ret = false; |
|
||||
if (parent == nullptr) { |
|
||||
ret = true; |
|
||||
} |
|
||||
return ret; |
|
||||
} |
|
||||
|
|
||||
void pEpTestUnit::data_dir_delete() |
|
||||
{ |
|
||||
try { |
|
||||
Utils::path_delete_all(getDataRoot()); |
|
||||
} catch (const exception& e) { |
|
||||
pEpLogClass("DistTest: - could not delete data dir: " + getDataRoot()); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
void pEpTestUnit::data_dir_create() |
|
||||
{ |
|
||||
// Utils::dir_create(getDataDir());
|
|
||||
pEpLogClass("creating dir:" + getDataRoot()); |
|
||||
} |
|
||||
|
|
||||
void pEpTestUnit::data_dir_recreate() |
|
||||
{ |
|
||||
data_dir_delete(); |
|
||||
data_dir_create(); |
|
||||
}; |
|
||||
|
|
||||
// static
|
|
||||
void pEpTestUnit::setDefaultExecutionMode(ExecutionMode emode) |
|
||||
{ |
|
||||
pEpTestUnit::emode_default = emode; |
|
||||
} |
|
||||
|
|
||||
pEpTestUnit::ExecutionMode pEpTestUnit::getExecutionMode() const |
|
||||
{ |
|
||||
return emode_chld; |
|
||||
} |
|
||||
|
|
||||
pEpTestUnit::ExecutionMode pEpTestUnit::getEffectiveExecutionMode() const |
|
||||
{ |
|
||||
ExecutionMode ret{ emode_default }; |
|
||||
if (getExecutionMode() == ExecutionMode::INHERIT) { |
|
||||
if (!isRootNode()) { |
|
||||
// get from parent until not inherit
|
|
||||
ret = parent->getEffectiveExecutionMode(); |
|
||||
} |
|
||||
} else { |
|
||||
ret = getExecutionMode(); |
|
||||
} |
|
||||
return ret; |
|
||||
} |
|
||||
|
|
||||
string pEpTestUnit::to_string(const ExecutionMode& emode) |
|
||||
{ |
|
||||
switch (emode) { |
|
||||
case ExecutionMode::FUNCTION: |
|
||||
return "FUNCTION"; |
|
||||
case ExecutionMode::PROCESS_SERIAL: |
|
||||
return "PROCESS_SERIAL"; |
|
||||
case ExecutionMode::PROCESS_PARALLEL: |
|
||||
return "PROCESS_PARALLEL"; |
|
||||
case ExecutionMode::THREAD_SERIAL: |
|
||||
return "THREAD_SERIAL"; |
|
||||
case ExecutionMode::THREAD_PARALLEL: |
|
||||
return "THREAD_PARALLEL"; |
|
||||
case ExecutionMode::INHERIT: |
|
||||
return "INHERIT"; |
|
||||
default: |
|
||||
return "UNDEFINED EXECUTION MODE"; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
string pEpTestUnit::to_string(bool recursive, int indent) const |
|
||||
{ |
|
||||
string ret; |
|
||||
stringstream builder; |
|
||||
builder << string(indent, '\t') << getName(); |
|
||||
builder << "[children=" << to_string(getEffectiveExecutionMode()) + "]"; |
|
||||
// builder << "/" << getModel().getName();
|
|
||||
builder << endl; |
|
||||
ret = builder.str(); |
|
||||
|
|
||||
if (recursive) { |
|
||||
indent++; |
|
||||
for (const pair<string, const pEpTestUnit&> elem : children) { |
|
||||
ret += elem.second.to_string(true, indent); |
|
||||
} |
|
||||
indent--; |
|
||||
} |
|
||||
return ret; |
|
||||
} |
|
||||
|
|
||||
const pEpTestUnit& pEpTestUnit::getParentProcessUnit() const |
|
||||
{ |
|
||||
if (!isRootNode()) { |
|
||||
if (parent->getEffectiveExecutionMode() == ExecutionMode::PROCESS_PARALLEL || |
|
||||
parent->getEffectiveExecutionMode() == ExecutionMode::PROCESS_SERIAL || |
|
||||
parent->isRootNode()) { |
|
||||
return *this; |
|
||||
} else { |
|
||||
return parent->getParentProcessUnit(); |
|
||||
} |
|
||||
} else { |
|
||||
return *this; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
//Well, ok, lets just add some little convenience logging service in here, too
|
|
||||
void pEpTestUnit::log(const string& msg) const |
|
||||
{ |
|
||||
stringstream builder; |
|
||||
builder << "[" << std::to_string(getpid()) << "/" << getParentProcessUnit().getFQName() |
|
||||
<< "] - "; |
|
||||
builder << msg << endl; |
|
||||
cout << builder.str(); |
|
||||
} |
|
||||
} // namespace Test
|
|
||||
} // namespace pEp
|
|
||||
@ -1,106 +0,0 @@ |
|||||
// This file is under GNU General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#ifndef LIBPEPADAPTER_PEPTESTUNIT_HH |
|
||||
#define LIBPEPADAPTER_PEPTESTUNIT_HH |
|
||||
|
|
||||
#include <string> |
|
||||
#include <functional> |
|
||||
#include <map> |
|
||||
#include "../../../src/pEpLog.hh" |
|
||||
#include "pEpTestModel.hh" |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace Test { |
|
||||
class pEpTestUnit { |
|
||||
public: |
|
||||
using TestUnitFunction = std::function<void(const pEpTestUnit&)>; |
|
||||
|
|
||||
enum class ExecutionMode |
|
||||
{ |
|
||||
FUNCTION, |
|
||||
PROCESS_SERIAL, |
|
||||
PROCESS_PARALLEL, |
|
||||
THREAD_SERIAL, // unimplemented
|
|
||||
THREAD_PARALLEL, // unimplemented
|
|
||||
INHERIT |
|
||||
}; |
|
||||
static std::string to_string(const ExecutionMode& emode); |
|
||||
|
|
||||
// Constructors
|
|
||||
pEpTestUnit() = delete; |
|
||||
|
|
||||
// Methods
|
|
||||
static pEpTestUnit createRootNode( |
|
||||
pEpTestModel& model, |
|
||||
const std::string& name, |
|
||||
const TestUnitFunction& test_func, |
|
||||
ExecutionMode emode_children = emode_default); |
|
||||
|
|
||||
static pEpTestUnit createChildNode( |
|
||||
pEpTestUnit& parent, |
|
||||
const std::string& name, |
|
||||
const TestUnitFunction& test_func, |
|
||||
ExecutionMode emode_children = emode_default); |
|
||||
|
|
||||
void init(const pEpTestUnit* caller = nullptr) const; |
|
||||
static void setDefaultDataRoot(const std::string& dir); |
|
||||
static std::string getDataRoot(); |
|
||||
void addChildNode(pEpTestUnit& node); |
|
||||
void run(const pEpTestUnit* caller = nullptr); |
|
||||
std::string getName() const; |
|
||||
std::string getFQName() const; |
|
||||
std::string getFQNameNormalized() const; |
|
||||
pEpTestModel& getModel() const; |
|
||||
std::string getDataDir() const; |
|
||||
const pEpTestUnit& getParentProcessUnit() const; |
|
||||
std::string to_string(bool recursive = true, int indent = 0) const; |
|
||||
static void setDefaultExecutionMode(ExecutionMode emode); |
|
||||
|
|
||||
//logging service
|
|
||||
void log(const std::string& msg) const; |
|
||||
|
|
||||
// internal logging
|
|
||||
static bool log_enabled; |
|
||||
Adapter::pEpLog::pEpLogger logger{ "pEpTestUnit", log_enabled }; |
|
||||
|
|
||||
private: |
|
||||
// Constructors
|
|
||||
explicit pEpTestUnit( |
|
||||
pEpTestUnit* parent, |
|
||||
pEpTestModel* model, |
|
||||
const std::string& name, |
|
||||
const TestUnitFunction& test_func, |
|
||||
ExecutionMode emode_children); |
|
||||
|
|
||||
// Methods
|
|
||||
const pEpTestUnit& getRoot() const; |
|
||||
void executeChildren() const; |
|
||||
void executeForked(pEpTestUnit& unit) const; |
|
||||
void waitChildProcesses() const; |
|
||||
ExecutionMode getExecutionMode() const; |
|
||||
ExecutionMode getEffectiveExecutionMode() const; |
|
||||
void data_dir_delete(); |
|
||||
void data_dir_create(); |
|
||||
void data_dir_recreate(); |
|
||||
bool isRootNode() const; |
|
||||
// bool isProcessNode() const;
|
|
||||
std::string normalizeName(std::string name) const; |
|
||||
|
|
||||
// Fields
|
|
||||
const pEpTestUnit* parent; //nullptr if rootnode
|
|
||||
const std::string name; |
|
||||
pEpTestModel* model; //nullptr if inherited
|
|
||||
const TestUnitFunction& test_func; |
|
||||
const ExecutionMode emode_chld; |
|
||||
static ExecutionMode emode_default; |
|
||||
std::map<const std::string, pEpTestUnit&> children; |
|
||||
static std::string data_root; |
|
||||
|
|
||||
// logger
|
|
||||
Adapter::pEpLog::pEpLogger& m4gic_logger_n4me = logger; |
|
||||
}; |
|
||||
}; // namespace Test
|
|
||||
}; // namespace pEp
|
|
||||
|
|
||||
#endif // LIBPEPADAPTER_PEPTESTUNIT_HH
|
|
||||
Loading…
Reference in new issue