/* ---- This file is part of SECONDO. Copyright (C) 2019, Faculty of Mathematics and Computer Science, Database Systems for New Applications. SECONDO is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. SECONDO 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 General Public License for more details. You should have received a copy of the GNU General Public License along with SECONDO; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ---- //[$][\$] */ #include #include #include #include #include "AlgebraTypes.h" #include "WorkerStatus.h" #include "QueryProcessor.h" std::string const JOB_STATUS_INIT = "created"; std::string const JOB_STATUS_RUNNING = "running"; std::string const JOB_STATUS_FINISHED = "finished"; std::string const JOB_STATUS_CANCELED = "canceled"; /* 1 Class DistributedJob Represents the currently running distributed job. Coordinates the ~WorkerStatus~ objects. */ class DistributedJob { std::string DEFAULT_JOURNAL_FILENAME = "DistributedJobsJournal.json"; public: /* Constructor */ DistributedJob(std::string _id, std::string _started, std::unordered_map _observableNodes, std::string _query, std::string _tree, std::string _nestedList, std::shared_ptr> _observableNodesWithNames, std::shared_ptr> _observableNodesWithArguments); /* Destructor */ ~DistributedJob(); /* ~getId~ Returns the ID of the job */ std::string getId(); /* ~getWorkers~ Returns the corresponding worker status objects in a unordered map */ std::shared_ptr >> getWorkers(); /* ~setWorkers~ Sets the corresponding worker status objects in a unordered map */ void setWorkers (std::shared_ptr>> workers); /* ~getStarted~ Returns the timestamp of the start */ std::string getStarted(); /* ~getStarted~ Returns the timestamp of the finish (blank if job is not finished yet) */ std::string getFinished(); /* ~getStatus~ Returns the status of the job */ std::string getStatus(); /* ~getFile~ Returns the correspondig file name */ std::string getFile(); /* ~getNumOfWorkers~ Returns the number of involved workers */ int getNumOfWorkers(); /* ~getJobNameForLog~ Returns the correspondig name meant to be used in the log */ std::string getJobNameForLog(); /* ~finishJob~ Sets the status to FINISHED with timestamp */ void finishJob(std::string time); /* ~getObservableNodes~ Returns the nodes to be observed in the job */ std::unordered_map getObservableNodes(); /* ~getObservableNodesList~ Returns the nodes to be observed in the job */ std::unordered_map getObservableNodesList(); /* ~getReadyNodeIds~ Returns IDs of finished nodes */ std::vector getReadyNodeIds(); /* ~getQuery~ Returns the entered query */ std::string getQuery(); /* ~getTree~ Returns the tree of the job (JSON) as a string */ std::string getTree(); /* ~getNowWorkingOnNodeId~ Returns the ID of the currently processed node */ int getNowWorkingOnNodeId(); /* ~populateObservableNodeIds~ Populates observable node IDs */ void populateObservableNodeIds(std::unordered_map _obsNodes); /* ~getObservableNodeIds~ Returns IDs of observable nodes */ std::vector getObservableNodeIds(); /* ~allWorkersFinished~ Returns ~true~ if all nodes finished */ bool allWorkersFinished(); /* ~setRunning~ Returns true at change, false if the status was not changed (was already running) */ bool setRunning(); /* ~setNumOfSlotsPerWorker~ Sets number of slots per worker */ void setNumOfSlotsPerWorker(int num); /* ~getNumOfSlotsPerWorker~ Returns number of slots per worker */ int getNumOfSlotsPerWorker(); /* ~getFiles~ Returns an array of log file names per worker */ std::vector getFiles(); /* ~pushFile~ Adds a file name to the array of file names per worker */ void pushFile(std::string file); /* ~getNestedList~ Returns corresponding nested list */ std::string getNestedList(); /* ~getObservableNodesWithNames~ Returns observalbe nodes with their names */ std::shared_ptr> getObservableNodesWithNames(); /* ~getObservableNodesWithArguments~ Returns observalbe nodes with their arguments separated by colon */ std::shared_ptr> getObservableNodesWithArguments(); /* ~setCanceled~ Sets the status to ~CANCELED~ */ void setCanceled(); /* ~clearObservableNodes~ Clears the list of observable nodes so no mapping can be accepted anymore until a new tree is created. */ void clearObservableNodes(); /* ~nextNode~ Marks currently processed node as finished and moves to the next node in the list. Returns true at success and false if there are no more nodes to move to */ template bool nextNode(int supplierId, QueryProcessor *qp, A *array) { markCurrentWorkingAtNodeAsProcessed(); if (observableNodes.size() > 0 && observableNodes.count(supplierId) > 0) { prepareNextNode(supplierId, qp, array); return true; } return false; } /* ~markCurrentWorkingAtNodeAsProcessed~ Marks currently processed node as finished */ void markCurrentWorkingAtNodeAsProcessed() { if (nowWorkingOnNodeId != -1 && !(processedNodesList.count(nowWorkingOnNodeId) > 0)) { processedNodesList .insert(std::make_pair(nowWorkingOnNodeId, nowWorkingOnNode)); } } /* ~allNodesProcessed~ Returns true if there are no more nodes to process and false else */ bool allNodesProcessed(); private: std::string id; std::string started; std::string finished; std::string status; std::string file; std::shared_ptr>> workerStatus; std::unordered_map observableNodes; Supplier nowWorkingOnNode; std::string query; std::string nestedList; std::string tree; std::unordered_map observableNodesList; std::unordered_map processedNodesList; int nowWorkingOnNodeId = -1; std::vector observableNodeIds{}; std::vector files{}; std::shared_ptr> observableNodesWithNames; std::shared_ptr> observableNodesWithArguments; int numOfslotsPerWorker = -1; /* ~prepareNextNode~ Prepares the next node to be processed */ template void prepareNextNode(int supplierId, QueryProcessor *qp, A *array) { nowWorkingOnNode = observableNodes.at(supplierId); nowWorkingOnNodeId = supplierId; removeSupplierFromList(supplierId); } /* ~removeSupplierFromList~ Removes ~supplierId~ from the list of observable nodes */ void removeSupplierFromList(int supplierId) { observableNodes.erase(supplierId); } };