void GraphIO::saveFulcrums(YAML::Node& fulcrum, const ConnectionDescription& connection)
{
fulcrum["from"] = connection.from.getFullName();
fulcrum["to"] = connection.to.getFullName();
for (const Fulcrum& f : connection.fulcrums) {
YAML::Node pt;
pt.push_back(f.pos().x);
pt.push_back(f.pos().y);
fulcrum["pts"].push_back(pt);
}
for (const Fulcrum& f : connection.fulcrums) {
YAML::Node handle;
handle.push_back(f.handleIn().x);
handle.push_back(f.handleIn().y);
handle.push_back(f.handleOut().x);
handle.push_back(f.handleOut().y);
fulcrum["handles"].push_back(handle);
}
for (const Fulcrum& f : connection.fulcrums) {
fulcrum["types"].push_back(f.type());
}
}
void LootSettings::upgradeYaml(YAML::Node& yaml) {
// Upgrade YAML settings' keys and values from those used in earlier
// versions of LOOT.
if (yaml["Debug Verbosity"] && !yaml["enableDebugLogging"])
yaml["enableDebugLogging"] = yaml["Debug Verbosity"].as<unsigned int>() > 0;
if (yaml["Update Masterlist"] && !yaml["updateMasterlist"])
yaml["updateMasterlist"] = yaml["Update Masterlist"];
if (yaml["Game"] && !yaml["game"])
yaml["game"] = yaml["Game"];
if (yaml["Language"] && !yaml["language"])
yaml["language"] = yaml["Language"];
if (yaml["Last Game"] && !yaml["lastGame"])
yaml["lastGame"] = yaml["Last Game"];
if (yaml["Games"] && !yaml["games"]) {
yaml["games"] = yaml["Games"];
for (auto node : yaml["games"]) {
if (node["url"]) {
node["repo"] = node["url"];
node["branch"] = "master"; // It'll get updated to the correct default
}
}
}
if (yaml["games"]) {
// Handle exception if YAML is invalid, eg. if an unrecognised
// game type is used (which can happen if downgrading from a
// later version of LOOT that supports more game types).
// However, can't remove elements from a sequence Node, so have to
// copy the valid elements into a new node then overwrite the
// original.
YAML::Node validGames;
for (auto node : yaml["games"]) {
try {
GameSettings settings(node.as<GameSettings>());
if (!yaml["Games"]) {
// Update existing default branch, if the default
// repositories are used.
if (settings.RepoURL() == GameSettings(settings.Type()).RepoURL()
&& settings.IsRepoBranchOldDefault()) {
settings.SetRepoBranch(GameSettings(settings.Type()).RepoBranch());
}
}
validGames.push_back(settings);
} catch (...) {}
}
yaml["games"] = validGames;
}
if (yaml["filters"])
yaml["filters"].remove("contentFilter");
}
YAML::Node& Generator::on_generate_votes ( const YAML::Node & msg, YAML::Node & ret )
{
ret["type"] = "votes_generated";
uint V = msg["data"][0].as<uint>();
uint O = msg["data"][1].as<uint>();
Integer p = msg["data"][2].as<Integer>();
Integer g = msg["data"][3].as<Integer>();
Integer k = Integer::Random ( p / 2, p );
ret["data"][0][0] = k;
std::set<Integer> T;
while ( T.size() < V )
{
T.insert ( Integer::Random ( p / 2, p ) );
}
for ( Integer t: T )
{
YAML::Node card;
Integer y;
do
{
y = Integer::Random ( p / 2, p - Integer ( 1 ) );
}
while ( Integer::Call ( mpz_gcd, y, p - Integer ( 1 ) ) != 1 ) ;
Integer gt = Integer::Call ( mpz_powm, g, t, p );
Integer gy = Integer::Call ( mpz_powm, g, y, p );
Integer P ( 1 );
for ( uint i = 0; i < O; ++i )
{
YAML::Node option;
P = Integer::NextPrime ( P );
Integer o = ( P * Integer::Call ( mpz_powm, g, k * t, p ) ) % p;
Integer s = ( ( o - t * gy ) * Integer::Call ( mpz_powm, y, Integer ( -1 ), p - Integer ( 1 ) ) ) % ( p - Integer ( 1 ) );
option[0] = gt;
option[1] = o;
option[2] = gy;
option[3] = s;
card.push_back ( option );
}
ret["data"][0][1].push_back ( gt );
ret["data"][1].push_back ( card );
}
return ret;
}
static inline YAML::Node extract(const std::string& start_link, const std::string& end_link, const KDL::Chain& chain)
{
std::string var_suffix = "_var";
std::string frame_suffix = "_frame";
std::string expression_name = "fk";
std::vector<YAML::Node> input_vars;
std::vector<YAML::Node> joint_frames;
YAML::Node frame_mul;
YAML::Node axis_angle_null;
axis_angle_null["axis-angle"].push_back(get_vector3(1, 0, 0));
axis_angle_null["axis-angle"].push_back(0);
int input_var_index = 0;
for (std::vector<KDL::Segment>::const_iterator it = chain.segments.begin(); it != chain.segments.end(); ++it)
{
KDL::Joint joint = it->getJoint();
std::string var_name = joint.getName() + var_suffix;
std::string frame_name = joint.getName() + frame_suffix;
YAML::Node joint_frame;
if (joint.getType() != KDL::Joint::None)
{
// Set input variable definition
YAML::Node input_var;
input_var[joint.getName() + var_suffix]["input-var"] = input_var_index;
input_var_index++;
input_vars.push_back(input_var);
// Set joint transform
YAML::Node translation;
YAML::Node rotation;
// Set joint axis
YAML::Node joint_axis = get_vector3(joint.JointAxis());
if (joint.getType() == KDL::Joint::TransAxis)
{
YAML::Node scale_vec;
scale_vec["scale-vector"].push_back(var_name);
scale_vec["scale-vector"].push_back(joint_axis);
translation["vector-add"].push_back(scale_vec);
translation["vector-add"].push_back(get_vector3(joint.JointOrigin()));
rotation = axis_angle_null;
}
else if (joint.getType() == KDL::Joint::RotAxis)
{
translation = get_vector3(joint.JointOrigin());
rotation["axis-angle"].push_back(joint_axis);
rotation["axis-angle"].push_back(var_name);
}
// Create frame and add to list
YAML::Node joint_transform;
joint_transform["frame"].push_back(rotation);
joint_transform["frame"].push_back(translation);
joint_frame[frame_name]["frame-mul"].push_back(joint_transform);
}
std::vector<YAML::Node> f_tip_nodes = get_frame_tip_nodes(*it);
for (std::vector<YAML::Node>::iterator f_tip_it = f_tip_nodes.begin(); f_tip_it != f_tip_nodes.end(); ++f_tip_it)
{
joint_frame[frame_name]["frame-mul"].push_back(*f_tip_it);
}
if (joint_frame.size() > 0)
{
joint_frames.push_back(joint_frame);
frame_mul.push_back(frame_name);
}
}
// Merge nodes
YAML::Node node;
for (std::vector<YAML::Node>::iterator it = input_vars.begin(); it != input_vars.end(); ++it)
{
node.push_back(*it);
}
for (std::vector<YAML::Node>::iterator it = joint_frames.begin(); it != joint_frames.end(); ++it)
{
node.push_back(*it);
}
YAML::Node fk_def;
fk_def[expression_name]["frame-mul"] = frame_mul;
node.push_back(fk_def);
return node;
}
YAML::Node getAddr () {
YAML::Node me;
me.push_back(ip);
me.push_back(port);
return me;
}
int main(int argc, const char* argv[])
{
try
{
std::string qdataxmlfilen;
if(argc < 2)
{
if(getenv("QDATA_XML_FILE") == NULL)
{
std::cout << "Please set the QDATA_XML_FILE variable or supply an argument." << std::endl;
exit(0);
}
else
{
qdataxmlfilen = getenv("QDATA_XML_FILE");
}
}
else
{
qdataxmlfilen = argv[1];
}
std::auto_ptr<qdata_t> doc(qdata(qdataxmlfilen));
YAML::Node outdoc;
if(std::string(doc->type()) == "ELEMENT")
{
if(!doc->header().present())
{
std::cout << "Document declared ELEMENT type, yet missing <header> element." << std::endl;
exit(-1);
}
YAML::Node odoc;
outdoc["header"].push_back(odoc);
header_t h = doc->header().get();
odoc["name"] = std::string(h.name());
odoc["author"] = std::string(h.author());
odoc["description"] = std::string(h.description());
odoc["extra"] = std::string(h.extra());
odoc["maxquestions"] = int(h.maxquestions());
if(h.skipoverride().present())
odoc["skipoverride"] = bool(h.skipoverride().get());
if(h.answernumberinput().present())
odoc["answernumberinput"] = bool(h.answernumberinput().get());
if(h.skipisincorrect().present())
odoc["skipisincorrect"] = bool(h.skipisincorrect().get());
if(h.quizmode().present())
odoc["quizmode"] = bool(h.quizmode().get());
if(!doc->questions().present())
{
std::cout << "Document declared ELEMENT type, yet missing <questions> element." << std::endl;
exit(-1);
}
YAML::Node qdoc;
outdoc["questions"].push_back(qdoc);
questions_t q = doc->questions().get();
questions_t::problem_sequence& qseq = q.problem();
int index = 1;
for(questions_t::problem_iterator iter = qseq.begin();
iter != qseq.end();
iter++)
{
question_t ques(*iter);
YAML::Node cques;
qdoc["q" + toString(index)].push_back(cques);
cques["question"] = std::string(ques.question());
answers_t answers = ques.answers();
YAML::Node answersnode;
cques["answers"] = answersnode;
answers_t::answer_sequence& aseq = answers.answer();
for(answers_t::answer_iterator iter2 = aseq.begin();
iter2 != aseq.end();
iter2++)
{
answersnode.push_back(std::string(*iter2));
}
cques["correctanswer"] = int(ques.correctanswer());
index++;
}
}
else if (std::string(doc->type()) == "ATTRIBUTE")
{
if(!doc->headera().present())
{
std::cout << "Document declared ATTRIBUTE type, yet missing <headera> element." << std::endl;
exit(-1);
}
YAML::Node odoc;
outdoc["header"] = odoc;
headera_t h = doc->headera().get();
odoc["name"] = std::string(h.name());
odoc["author"] = std::string(h.author());
odoc["description"] = std::string(h.description());
odoc["extra"] = std::string(h.extra());
odoc["maxquestions"] = int(h.maxquestions());
if(h.skipoverride().present())
odoc["skipoverride"] = bool(h.skipoverride().get());
if(h.answernumberinput().present())
odoc["answernumberinput"] = bool(h.answernumberinput().get());
if(h.skipisincorrect().present())
odoc["skipisincorrect"] = bool(h.skipisincorrect().get());
if(h.quizmode().present())
odoc["quizmode"] = bool(h.quizmode().get());
if(!doc->questionsa().present())
{
std::cout << "Document declared ATTRIBUTE type, yet missing <questionsa> element." << std::endl;
exit(-1);
}
YAML::Node qdoc;
outdoc["questions"] = qdoc;
questionsa_t q = doc->questionsa().get();
questionsa_t::problem_sequence& qseq = q.problem();
int index = 1;
for(questionsa_t::problem_iterator iter = qseq.begin();
iter != qseq.end();
iter++)
{
questiona_t ques(*iter);
YAML::Node cques;
qdoc["q" + toString(index)] = cques;
cques["question"] = std::string(ques.question());
answersa_t answers = ques.answers();
YAML::Node answersnode;
cques["answers"] = answersnode;
answersa_t::answer_sequence& aseq = answers.answer();
for(answersa_t::answer_iterator iter2 = aseq.begin();
iter2 != aseq.end();
iter2++)
{
answera_t ans(*iter2);
answersnode.push_back(std::string(ans.value()));
}
cques["correctanswer"] = int(ques.correctanswer());
index++;
}
}
std::ofstream fout((doc->name() + ".lsybin").c_str());
if(fout.is_open())
{
fout << outdoc;
fout.close();
}
else
{
std::cout << "Error opening/creating file." << std::endl;
exit(0);
}
}
catch (const xml_schema::exception& ex) {
std::cout << ex << std::endl;
}
}
virtual void launchTask(ExecutorDriver* driver, const TaskInfo& task) {
localPeerCount++;
TaskStatus status;
status.mutable_task_id()->MergeFrom(task.task_id());
status.set_state(TASK_RUNNING);
driver->sendStatusUpdate(status);
//------------- START TASK OPERATIONS ----------
cout << "Running K3 Program: " << task.name() << endl;
string k3_cmd;
using namespace YAML;
Node hostParams = Load(task.data());
Node peerParams;
Node peers;
// vector<Node> peers;
cout << "WHAT I RECEIVED\n----------------------\n";
cout << Dump(hostParams);
cout << "\n---------------------------------\n";
k3_cmd = "cd $MESOS_SANDBOX && bash -c 'ulimit -c unlimited && ./" + hostParams["binary"].as<string>();
if (hostParams["logging"]) {
k3_cmd += " -l INFO ";
}
if (hostParams["resultVar"]) {
k3_cmd += " --result_path $MESOS_SANDBOX --result_var " + hostParams["resultVar"].as<string>();
}
string datavar, datapath;
string datapolicy = "default";
int peerStart = 0;
int peerEnd = 0;
for (const_iterator param=hostParams.begin(); param!=hostParams.end(); param++) {
string key = param->first.as<string>();
// cout << " PROCESSING: " << key << endl;
if (key == "logging" || key == "binary" ||
key == "server" || key == "server_group") {
continue;
}
if (key == "roles") {
continue;
}
else if (key == "peers") {
peerParams["peers"] = hostParams["peers"];
}
else if (key == "me") {
Node meList = param->second;
YAML::Emitter emit;
emit << YAML::Flow << meList;
for (std::size_t i=0; i<meList.size(); i++) {
peers.push_back(meList[i]);
}
}
else if (key == "data") {
// TODO: Datafiles per group. This is a hack
// that only includes the data files from the first peer group
// and assigns them to any peer
Node dataFilesNode = param->second[0];
for(YAML::const_iterator it=dataFilesNode.begin();it!=dataFilesNode.end();++it) {
DataFile f;
auto d = *it;
f.path = d["path"].as<string>();
f.varName = d["var"].as<string>();
f.policy = d["policy"].as<string>();
dataFiles.push_back(f);
}
}
//else if (key == "datavar") {
// datavar = param->second.as<string>();
//}
//else if (key == "datapath") {
// datapath = "{path: " + param->second.as<string>() + "}";
//}
//else if (key == "datapolicy") {
// datapolicy = param->second.as<string>();
//}
else if (key == "totalPeers") {
totalPeerCount = param->second.as<int>();
}
else if (key == "peerStart") {
peerStart = param->second.as<int>();
}
else if (key == "peerEnd") {
peerEnd = param->second.as<int>();
}
else if (key == "globals") {
// handled per peer
}
else {
// string value = i->second.as<string>();
//peerParams[key] = param->second;
}
}
// DATA ALLOCATION *
// TODO: Convert to multiple input dirs
map<string, vector<string> > peerFiles[peers.size()];
for (auto dataFile : dataFiles) {
cout << "Top of loop" << endl;
vector<string> filePaths;
// 1. GET DIR LIST IN datavar
DIR *datadir = NULL;
datadir = opendir(dataFile.path.c_str());
if (!datadir) {
cout << "Failed to open data dir: " << dataFile.path << endl;
TaskStatus status;
status.mutable_task_id()->MergeFrom(task.task_id());
status.set_state(TASK_FAILED);
driver->sendStatusUpdate(status);
return;
}
else {
cout << "Opened data dir: " << dataFile.path << endl;
}
struct dirent *srcfile = NULL;
while (true) {
srcfile = readdir(datadir);
if (srcfile == NULL) {
break;
}
cout << "FILE " << srcfile->d_name << ": ";
if (srcfile->d_type == DT_REG) {
string filename = srcfile->d_name;
filePaths.push_back(dataFile.path + "/" + filename);
cout << "Added -> " << filename;
}
cout << endl;
}
closedir(datadir);
cout << "read directory" << endl;
int numfiles = filePaths.size();
sort (filePaths.begin(), filePaths.end());
int p_start = 0;
int p_end = numfiles;
int p_total = peers.size();
int myfiles = 0;
if (dataFile.policy == "global") {
for (int i = 0; i < numfiles; i++) {
int peer = i % totalPeerCount;
if (peer >= peerStart && peer <= peerEnd) {
myfiles++;
peerFiles[peer-peerStart][dataFile.varName].push_back(filePaths[i]);
}
}
}
else if (dataFile.policy == "replicate") {
for (int p = 0; p < peers.size(); p++) {
for (int i =0; i < numfiles; i++) {
myfiles++;
peerFiles[p][dataFile.varName].push_back(filePaths[i]);
}
}
}
//if (dataFile.policy == "global") {
// p_start = (numfiles / totalPeerCount) * peerStart;
// p_end = (numfiles / totalPeerCount) * (peerEnd+1);
// p_total = totalPeerCount;
// cout << ("Global files s=" + stringify(p_start) + " e=" + stringify(p_end) + " t=" + stringify(p_total)) << endl;
// for (int filenum = p_start; filenum < p_end; filenum++) {
// int peer = floor((((p_total)*1.0*filenum) / numfiles)) - peerStart;
// cout << " Peer # " << peer << " : [" << filenum << "] " << filePaths[filenum] << endl;
// peerFiles[peer][dataFile.varName].push_back(filePaths[filenum]);
// myfiles++;
// }
//}
else if (dataFile.policy == "pinned") {
for(int filenum = 0; filenum < numfiles; filenum++) {
peerFiles[0][dataFile.varName].push_back(filePaths[filenum]);
}
}
else if (dataFile.policy == "sharded") {
for (int i =0; i < numfiles; i++) {
myfiles++;
int p = i % peers.size();
peerFiles[p][dataFile.varName].push_back(filePaths[i]);
}
}
cout << "my files: " << myfiles << endl;
}
cout << "BUILDING PARAMS FOR PEERS" << endl;
int pph = 0;
if (peerParams["peers"].size() >= 1) {
YAML::Node peer_masters;
YAML::Node masters;
YAML::Node curMaster = YAML::Load(YAML::Dump(peerParams["peers"][0]));
masters.push_back(YAML::Load(YAML::Dump(curMaster)));
std::cout << peerParams["peers"].size() << " peers to map" << endl;
for (std::size_t i=0; i< peerParams["peers"].size(); i++) {
YAML::Node kv;
if (peerParams["peers"][i]["addr"][0].as<string>() != curMaster["addr"][0].as<string>()) {
cout << "Host: " << curMaster["addr"][0].as<string>() << ". Peers: " << pph << endl;
pph = 0;
masters.push_back(YAML::Load(YAML::Dump(peerParams["peers"][i])));
curMaster = YAML::Load(YAML::Dump(peerParams["peers"][i]));
}
pph++;
std::cout << "added one" << endl;
kv["key"] = YAML::Load(YAML::Dump(peerParams["peers"][i]["addr"]));
kv["value"] = YAML::Load(YAML::Dump(curMaster["addr"]));
peer_masters.push_back(kv);
}
cout << "Host: " << curMaster["addr"][0].as<string>() << ". Peers: " << pph << endl;
peerParams["peer_masters"] = YAML::Load(YAML::Dump(peer_masters));
peerParams["masters"] = YAML::Load(YAML::Dump(masters));
std::cout << "Masters: " << YAML::Dump(masters) << endl;
}
std::ostringstream oss;
oss << "PEERS!!! (" << std::endl;
for (std::size_t i=0; i<peers.size(); i++) {
oss << "---" << std::endl;
YAML::Node thispeer = peerParams;
YAML::Node globals = hostParams["globals"][i];
for (const_iterator p=globals.begin(); p!=globals.end(); p++) {
thispeer[p->first.as<string>()] = p->second;
}
YAML::Node me = peers[i];
thispeer["me"] = me;
YAML::Node local_peers;
std::cout << "start: " << peerStart << ". end: " << peerEnd << std::endl;
for (int j=peerStart; j<= peerEnd; j++) {
local_peers.push_back(YAML::Load(YAML::Dump(peerParams["peers"][j])));
}
thispeer["local_peers"] = YAML::Load(YAML::Dump(local_peers));
for (auto it : peerFiles[i]) {
auto datavar = it.first;
if (thispeer[datavar]) {
thispeer.remove(datavar);
}
for (auto &f : it.second) {
Node src;
src["path"] = f;
thispeer[datavar].push_back(src);
}
}
// ADD DATA SOURCE DIR HERE
YAML::Emitter emit;
emit << YAML::Flow << thispeer;
string param = emit.c_str();
std::ofstream peerFile;
string peerFileName = "/mnt/mesos/sandbox/peers" + std::to_string(i) + ".yaml";
peerFile.open(peerFileName, std::ofstream::out);
peerFile << param;
peerFile.close();
oss << param << std::endl;
std::cout << param << std::endl;
k3_cmd += " -p " + peerFileName;
for (auto it : peerFiles[i]) {
auto datavar = it.first;
if (thispeer[datavar]) {
thispeer.remove(datavar);
}
}
}
oss << ") END PEERS!!!" << std::endl;
cout << oss.str() << std::endl;
k3_cmd += "'";
cout << "FINAL COMMAND: " << k3_cmd << endl;
if (thread) {
driver->sendFrameworkMessage("Debug: thread already existed!");
thread->interrupt();
thread->join();
delete thread;
thread = 0;
}
bool isMaster = false;
cout << "Checking master" << endl;
if (Dump(hostParams["me"][0]) == Dump(hostParams["master"])) {
isMaster = true;
cout << "I am master" << endl;
}
else {
cout << "me: " << Dump(hostParams["me"][0]) << endl;
cout << "master: " << Dump(hostParams["master"]) << endl;
}
cout << "Launching K3: " << endl;
thread = new boost::thread(TaskThread(task, k3_cmd, driver, isMaster));
}