Дипломному проекту На тему: Разработка программного модуля диспетчера высокой готовности для осрв qnx 25
Скачать 0.71 Mb.
|
ЗаключениеЦелью данного дипломного проекта была разработка программного обеспечения для создания унифицированного отказоустойчивого бортового вычислителя. В результате работы над дипломным проектом были решены следующие задачи:
Результатом работы стал программный продукт, входящий в состав комплекса кластерного программного обеспечения. Продукт прошел автономное тестирование и был полностью отлажен. В настоящий момент программное обеспечение передано предприятию для проведения комплексных испытаний в режиме рабочего применения и совместного тестирования на реальном оборудовании. Список литературы
Приложение//communication.cpp //Dmitry Saraev //ARGON, 2012 #include "communication.h" Communication::Communication(WCValSList { int regState; nodeList = listOfNodes; nodeNamePrefix = "/ARGON_CLUSTER_NODE_"; activeNodeName = "/ARGON_CLUSTER_NODE_MAIN"; regState = registerMyNodeName(); if(regState == -1) { cerr << "Error! Cant attach name: " << nodeNamePrefix << getnid() << endl; } } int Communication::registerMyNodeName() { return qnx_name_attach(0, nodeNamePrefix + String(getnid())); } void Communication::registerMyNodeAsMainNode() { mainNodeNameId = qnx_name_attach(0, nodeNamePrefix + "MAIN"); } void Communication::unregisterMyNodeAsMainNode() { qnx_name_detach(0, mainNodeNameId); } int Communication::nextNode(int nodeNum) { int nodeIndex; int totalNodes = nodeList.entries(); if(totalNodes == 1) { return 0; } nodeIndex = nodeList.index(nodeNum); assert(nodeIndex != -1); if((nodeIndex + 1) < totalNodes) { cout << "COMMUNICATION.CPP:if next node = " << nodeList.find(nodeIndex + 1) << endl; return nodeList.find(nodeIndex + 1); } else { cout << "COMMUNICATION.CPP:else next node = " << nodeList.find(0) << endl; return nodeList.find(0); } } int Communication::sendMessageToNextNode(message_struct *message) { int sendStatus = -1; int receiverNode = getnid(); do { receiverNode = nextNode(receiverNode); if((receiverNode == getnid()) || (receiverNode == 0)) { return MESSAGE_CANT_SEND; } pid_t receiver = qnx_name_locate(0, nodeNamePrefix + String(receiverNode), sizeof(message_struct), NULL); if(receiver != -1) { sendStatus = Send(receiver, message, message, sizeof(message_struct), sizeof(message_struct)); qnx_vc_detach(receiver); } } while(sendStatus != 0); return MESSAGE_SEND; } pid_t Communication::getMessage(message_struct *message) { pid_t sender; sender = Creceive(0, message, sizeof(message_struct)); if(sender == -1) { return NO_NEW_MESSAGES; } return sender; } int Communication::sendReplyMessage(message_struct *message, pid_t sender) { int replyState = Reply(sender, message, sizeof(message_struct)); return replyState; } //communication.h //Dmitry Saraev //ARGON, 2012 #ifndef COMMUNICATION_H #define COMMUNICATION_H #include "message_types.h" #include "parse_config.h" #include #include #include #include #include #include //info about state of nodes #define NODE_STATE_ACTIVE 1 #define NODE_STATE_PASSIVE 0 #define NODE_STATE_UNAVALIBLE 2 //info about state of send message #define MESSAGE_CANT_SEND 0 #define MESSAGE_SEND 1 //info about state of send reply to message #define REPLY_CANT_SEND -1 #define REPLY_SEND 0 //info about avalible nodes #define NODE_AVALIBLE 1 #define NODE_UNAVALIBLE 0 #define NO_NEW_MESSAGES 0 class Communication { public: Communication(WCValSList int sendMessageToNextNode(message_struct *message); pid_t getMessage(message_struct *message); int sendReplyMessage(message_struct *message, pid_t sender); void registerMyNodeAsMainNode(); void unregisterMyNodeAsMainNode(); private: String nodeNamePrefix; String activeNodeName; int registerMyNodeName(); int mainNodeNameId; WCValSList int nextNode(int nodeNum); }; #endif //proc_watch.cpp //Dmitry Saraev //ARGON, 2012 #include "proc_watch.h" LogEvents * log; SysProc::operator==(const SysProc &proc2) const { return (*procInfo == *proc2.procInfo); } SysProc::SysProc(ProcInfo *proc) { procInfo = proc; pid = -1; vid = -1; } SysProc::startOn(nid_t node) { pid_t procId; if((realStartNode == node) && (isRun())) { state = PROC_RUN; return PROC_START_OK; } //change qnx_spawn_options qnx_spawn_options.node = node; qnx_spawn_options.priority = procInfo->prio; log->startEvent("START-PROC :tag " + toString(procInfo->tag) + " :onNode " + toString(node)); if(procInfo->options == "") { procId = spawnl(P_NOWAIT, procInfo->filename, procInfo->filename, NULL); } else { char** options = stringToOptionList( procInfo->filename + " " + procInfo->options); procId = spawnv(P_NOWAIT, procInfo->filename, (char const * const *)options); } //restore qnx_spawn_options qnx_spawn_options.node = 0L; qnx_spawn_options.priority = -1; if(procId == -1) { state = PROC_NOT_RUN; log->endEvent("ERROR"); return PROC_START_ERROR; } realStartNode = node; vid = procId; if(node == getnid()) { pid = vid; } else { _psinfo data; qnx_psinfo(0, vid, &data, 0, NULL); pid = data.un.vproc.remote_pid; } qnx_vc_detach(vid); state = PROC_RUN; log->endEvent("OK :pid " + toString(pid)); return PROC_START_OK; } int SysProc::isRunLocalCheck() { if(pid == -1) { state = PROC_NOT_RUN; return PROC_NOT_RUN; } _psinfo data; if(qnx_psinfo(0, pid, &data, 0, NULL) == -1) { state = PROC_NOT_RUN; return PROC_NOT_RUN; } else if(data.pid != vid) { state = PROC_NOT_RUN; return PROC_NOT_RUN; } else if(data.state == STATE_DEAD) { state = PROC_NOT_RUN; return PROC_NOT_RUN; } else { state = PROC_RUN; return PROC_RUN; } } int SysProc::isRunGlobalCheck() { if(pid == -1) { state = PROC_NOT_RUN; return PROC_NOT_RUN; } waitpid(vid, NULL, WNOHANG); int oldVid = vid; vid = qnx_vc_attach(realStartNode, pid, 1000, 0); if(vid == -1) { state = PROC_NOT_RUN; qnx_vc_detach(oldVid); return PROC_NOT_RUN; } _psinfo data; if(qnx_psinfo(0, vid, &data, 0, NULL) == -1) { state = PROC_NOT_RUN; qnx_vc_detach(vid); return PROC_NOT_RUN; } else if(data.pid != vid) { state = PROC_NOT_RUN; qnx_vc_detach(vid); return PROC_NOT_RUN; } else if(data.state == STATE_DEAD) { state = PROC_NOT_RUN; qnx_vc_detach(vid); return PROC_NOT_RUN; } else { state = PROC_RUN; qnx_vc_detach(vid); return PROC_RUN; } } int SysProc::isRun() { log->startEvent("IS-PROC-RUN :tag " + toString(procInfo->tag)); if(realStartNode == getnid()) { isRunLocalCheck(); } else { isRunGlobalCheck(); } if(state == PROC_RUN) { log->endEvent("RUN"); } else { log->endEvent("NOT-RUN"); } return state; } int SysProc::stop() { log->startEvent("STOP-PROC :tag " + toString(procInfo->tag) + " :node " + toString(realStartNode) + " :pid " + toString(pid)); if(isRun() == PROC_NOT_RUN) { log->endEvent("OK"); return PROC_STOPPED; } sendSignalToMe(SIGTERM); if(isRun() == PROC_NOT_RUN) { log->endEvent("OK"); return PROC_STOPPED; } sendSignalToMe(SIGKILL); if(isRun() == PROC_NOT_RUN) { log->endEvent("OK"); return PROC_STOPPED; } log->endEvent("ERROR"); return PROC_CANT_STOPPED; } void SysProc::sendSignalToMe(int signalNumber) { String killCommand; char strNode[3]; char strPid[10]; char strSignal[3]; itoa(realStartNode, strNode, 10); itoa(pid, strPid, 10); itoa(signalNumber, strSignal, 10); killCommand = "on -n " + String(strNode) + " kill -" + String(strSignal) + " " + String(strPid); system(killCommand); } char ** SysProc::stringToOptionList(String s) { WCPtrSList String sep = " "; String sepOpen = "\""; String sepClose = "\""; int done = 0; int beginPos = 0; int endPos = 0; while(!done) { String * tmpStr = new(String); if(s[beginPos] == sepOpen) { ++beginPos; endPos = s.index(sepClose, beginPos); *tmpStr = String(s, beginPos, endPos - beginPos); if(s.length() == endPos + 1) { done = 1; } ++endPos; } else { endPos = s.index(sep, beginPos); if(endPos == -1) { endPos = s.length(); done = 1; } *tmpStr = String(s, beginPos, endPos - beginPos); } list.append(tmpStr); beginPos = endPos + 1; } //create option list char** opList = (char**)malloc(sizeof(char*) * (list.entries() + 1)); //convert from strings to char* [] int opNum = list.entries(); int opCounter = 0; while(opCounter < opNum) { String strOpt = *list.get(); char* option = (char*)malloc(sizeof(char) * (strOpt.length() + 1)); strcpy(option, strOpt); opList[opCounter] = option; ++opCounter; } opList[opCounter] = NULL; list.clearAndDestroy(); return opList; } ProcWatch::ProcWatch(WCPtrSList procs) { nodeNamePrefix = NODE_NAME_PREFIX; int nodeNum = nodes.entries(); int nodeCount = 0; WCPtrSList while(nodeCount < nodeNum) { NodeInfo * node = nodes.find(nodeCount); realNodes.append(node->node); RealNodeInfo * realNodeInfo = new RealNodeInfo(node->node, NS_PASSIVE); realNodesInfo.append(realNodeInfo); cout << "debug: add node " << node->node << " to realNodesInfo" << endl; ++nodeCount; } nodesInfo = new NodesInfo(realNodesInfo); } int ProcWatch::myState() { return nodesInfo->realNodeState(getnid()); } void ProcWatch::startMonitoring() { clusterState = new ClusterState(); int selectionTimeout = getnid() * 5; registerMyNodeName(); delay(5000); int noNodesTime; while(1) { delay(MESSAGE_TIMEOUT); ++clusterState->cycle; log->startEvent("MONITORING :cycle " + toString(clusterState->cycle)); answerToAllMessages(); if(myState() == NS_PASSIVE) { if(clusterState->cycleOfLastMessage < clusterState->cycle - (getnid() * 5)) { nodesInfo->reset(); if(startSelection() == MESSAGE_CANT_SEND) { log->startEvent("SET-MY-NODE-AS-MAIN"); setMyState(NS_ACTIVE); log->endEvent("OK"); } } } if(myState() == NS_ACTIVE) { if(sendMsgClusterState() == MESSAGE_CANT_SEND) //TODO this function { int myOldState = myState(); nodesInfo->reset(); if(myOldState != myState()) { RealNodeInfo * myNode = nodesInfo->getNode(getnid()); myNode->status = myOldState; } } } log->endEvent("OK"); } } int ProcWatch::sendMsgClusterState() { message_struct message; message.magic_number = ARGON_MAGIC_NUMBER; message.type = MT_CLUSTER_CHANGES; message.sender = getnid(); message.message_body.changes_in_cluster.cluster_state_rev = clusterState->currentRev; message.message_body.changes_in_cluster.node_count = realNodes.entries(); int nodesTotal = realNodes.entries(); int nodesCount = 0; while(nodesCount < nodesTotal) { int currentNode = realNodes.find(nodesCount); assert(currentNode != -1); if(currentNode == getnid()) { message.message_body.changes_in_cluster.nodes[nodesCount].node_number = getnid(); message.message_body.changes_in_cluster.nodes[nodesCount].node_status = NS_ACTIVE; message.message_body.changes_in_cluster.nodes[nodesCount].node_weight = nodesInfo->getWidthOnNode(getnid()); message.message_body.changes_in_cluster.nodes[nodesCount].node_have_changes = NC_NONE; } else { message.message_body.changes_in_cluster.nodes[nodesCount].node_number = currentNode; message.message_body.changes_in_cluster.nodes[nodesCount].node_status = NS_UNAVAILIBLE; message.message_body.changes_in_cluster.nodes[nodesCount].node_weight = nodesInfo->getWidthOnNode(currentNode); message.message_body.changes_in_cluster.nodes[nodesCount].node_have_changes = NC_NONE; } ++nodesCount; } return sendMessageToNextNode(&message); } int ProcWatch::updateNodesList() { cout << "(SEND-MESSAGE LIST_OF_NODES)" << endl; message_struct message; message.magic_number = ARGON_MAGIC_NUMBER; message.type = MT_LIST_OF_NODES; message.sender = getnid(); message.message_body.node_list.node_count = 1; message.message_body.node_list.nodes[0].node_number = getnid(); message.message_body.node_list.nodes[0].node_status = myState(); message.message_body.node_list.nodes[0].node_weight = nodesInfo->getWidthOnNode(getnid()); return sendMessageToNextNode(&message); } int ProcWatch::startSelection() { cout << "(SEND-MESSAGE SELECTION)" << endl; message_struct message; message.magic_number = ARGON_MAGIC_NUMBER; message.type = MT_SELECTION; message.sender = getnid(); message.message_body.changes_in_cluster.cluster_state_rev = 0; message.message_body.changes_in_cluster.node_count = realNodes.entries(); int nodesTotal = realNodes.entries(); int nodesCount = 0; while(nodesCount < nodesTotal) { int currentNode = realNodes.find(nodesCount); assert(currentNode != -1); if(currentNode == getnid()) { message.message_body.changes_in_cluster.nodes[nodesCount].node_number = getnid(); message.message_body.changes_in_cluster.nodes[nodesCount].node_status = NS_ACTIVE; message.message_body.changes_in_cluster.nodes[nodesCount].node_weight = nodesInfo->getWidthOnNode(getnid()); message.message_body.changes_in_cluster.nodes[nodesCount].node_have_changes = NC_NONE; } else { message.message_body.changes_in_cluster.nodes[nodesCount].node_number = currentNode; message.message_body.changes_in_cluster.nodes[nodesCount].node_status = NS_UNAVAILIBLE; message.message_body.changes_in_cluster.nodes[nodesCount].node_weight = nodesInfo->getWidthOnNode(currentNode); message.message_body.changes_in_cluster.nodes[nodesCount].node_have_changes = NC_NONE; } ++nodesCount; } return sendMessageToNextNode(&message); } void ProcWatch::setMyState(int nodeState) { if(myState() == nodeState) { return; } else if(myState() == NS_ACTIVE) { unregisterMyNodeAsMainNode(); } else if(myState() == NS_PASSIVE) { registerMyNodeAsMainNode(); } RealNodeInfo * myNode = nodesInfo->getNode(getnid()); myNode->status = nodeState; } void ProcWatch::setNodeState(int nodeNum, int nodeState) { RealNodeInfo * node = nodesInfo->getNode(nodeNum); node->status = nodeState; } int ProcWatch::answerMessage(message_struct * message, message_struct * newMessage) { log->startEvent("(GET_MESSAGE)"); int sendToNextNode; switch(message->type) { case MT_SELECTION: sendToNextNode = answerToMtSelection(message, newMessage); break; case MT_NEW_ACTIVE_NODE: sendToNextNode = answerToMtNewActiveNode(message, newMessage); break; case MT_LIST_OF_NODES: sendToNextNode = answerToMtListOfNodes(message, newMessage); break; case MT_CLUSTER_CHANGES: sendToNextNode = answerToMtClusterChanges(message, newMessage); break; case MT_TOTAL_PROCS_COUNT: sendToNextNode = answerToMtTotalProcsCount(message, newMessage); break; case MT_PROCS_STATUS: sendToNextNode = answerToMtProcsStatus(message, newMessage); break; case MT_TOTAL_UPDATED_PROCS: sendToNextNode = answerToMtTotalUpdatedProcs(message, newMessage); break; case MT_UPDATE_IN_PROCS_LIST: sendToNextNode = answerToMtUpdateInProcsList(message, newMessage); break; case MT_UPDATE_IN_NODES_LIST: sendToNextNode = answerToMtUpdateInNodesList(message, newMessage); break; } log->endEvent("[OK]"); return sendToNextNode; } int ProcWatch::answerToMtSelection(message_struct * message, message_struct * newMessage) { cout << "debug: ProcWatch::answerToMtSelection" << endl; //int answer = answerToMtUpdateInNodesList(message, newMessage); if(getnid() != message->sender) { *newMessage = *message; int nodesTotal = message->message_body.changes_in_cluster.node_count; int nodesCounter = 0; while(nodesCounter < nodesTotal) { node_changes_struct node = message->message_body.changes_in_cluster.nodes[nodesCounter]; if(node.node_number == getnid()) { node.node_status = myState(); node.node_weight = nodesInfo->getWidthOnNode(getnid()); node.node_have_changes = NC_NONE; newMessage->message_body.changes_in_cluster.nodes[nodesCounter] = node; break; } ++nodesCounter; } return SEND_MESSAGE_TO_NEXT_NODE; } else { if(nodesInfo->haveActiveNode()) { cout << "debug: active Node exist" << endl; return NOT_SEND_MESSAGE_TO_NEXT_NODE; } else { int newMainNode = nodesInfo->findMinWidthRealNode(); *newMessage = generateMtNewActiveNode(newMainNode); cout << "active Node not exist new active node is: " << newMainNode << endl; return SEND_MESSAGE_TO_NEXT_NODE; } } } int ProcWatch::answerToMtListOfNodes(message_struct * message, message_struct * newMessage) { int totalAvailibleNodes = 0; int nodesCount = 0; int totalNodes = realNodes.entries(); while(nodesCount < totalNodes) { int nodeNum = realNodes.find(nodesCount); if(nodesInfo->isRealNodeAvailible(nodeNum)) { RealNodeInfo * node = nodesInfo->getNode(nodeNum); message->message_body.node_list.nodes[nodesCount].node_number = node->node; message->message_body.node_list.nodes[nodesCount].node_status = node->status; message->message_body.node_list.nodes[nodesCount].node_weight = nodesInfo->getWidthOnNode(nodeNum); ++totalAvailibleNodes; } ++nodesCount; } message->message_body.node_list.node_count = totalAvailibleNodes; return NOT_SEND_MESSAGE_TO_NEXT_NODE; } int ProcWatch::answerToMtClusterChanges(message_struct * message, message_struct * newMessage) { if(getnid() == message->sender) { int myOldState = myState(); int nodesCount = 0; int totalNodes = message->message_body.node_list.node_count; while(nodesCount < totalNodes) { node_changes_struct node = message->message_body.changes_in_cluster.nodes[nodesCount]; RealNodeInfo * realNode = nodesInfo->getNode(node.node_number); realNode->status = node.node_status; realNode->haveChanges = node.node_have_changes; ++nodesCount; } return NOT_SEND_MESSAGE_TO_NEXT_NODE; } else { *newMessage = *message; int nodesCount = 0; int totalNodes = newMessage->message_body.node_list.node_count; while(nodesCount < totalNodes) { if(newMessage->message_body.changes_in_cluster.nodes[nodesCount].node_number == getnid()) { newMessage->message_body.changes_in_cluster.nodes[nodesCount].node_status = myState(); newMessage->message_body.changes_in_cluster.nodes[nodesCount].node_weight = nodesInfo->getWidthOnNode(getnid()); return SEND_MESSAGE_TO_NEXT_NODE; } ++nodesCount; } return SEND_MESSAGE_TO_NEXT_NODE; } } int ProcWatch::answerToMtNewActiveNode(message_struct * message, message_struct * newMessage) { if((myState() == NS_ACTIVE) && (getnid() != message->message_body.node_number)) { setMyState(NS_PASSIVE); } else if(getnid() == message->message_body.node_number) { setMyState(NS_ACTIVE); } setNodeState(message->message_body.node_number, NS_ACTIVE); *newMessage = *message; if(getnid() == message->sender) { return NOT_SEND_MESSAGE_TO_NEXT_NODE; } else { return SEND_MESSAGE_TO_NEXT_NODE; } } int ProcWatch::answerToMtTotalProcsCount(message_struct * message, message_struct * newMessage) { //message->message_body.proc_count = runtimeProcs.entries(); //driver_begin message->message_body.proc_count = 123; //driver_end return NOT_SEND_MESSAGE_TO_NEXT_NODE; } int ProcWatch::answerToMtProcsStatus(message_struct * message, message_struct * newMessage) { int procCount = 0; int totalProcInMsg = message->message_body.procs_status.procs_count; proc_struct proc; while(procCount < totalProcInMsg) { proc = message->message_body.procs_status.procs[procCount]; ++procCount; } return NOT_SEND_MESSAGE_TO_NEXT_NODE; } int ProcWatch::answerToMtTotalUpdatedProcs(message_struct * message, message_struct * newMessage) { if(message->sender == getnid()) { return NOT_SEND_MESSAGE_TO_NEXT_NODE; } else { clusterState->newRev = message->message_body.num_of_updates.cluster_state_rev; if((clusterState->newRev == (clusterState->currentRev + 1)) || ((clusterState->newRev != clusterState->currentRev) && (message->message_body.num_of_updates.update_type == UT_FULL))) { clusterState->remainingUpdates = message->message_body.num_of_updates.total_updates; } } return SEND_MESSAGE_TO_NEXT_NODE; } int ProcWatch::answerToMtUpdateInProcsList(message_struct * message, message_struct * newMessage) { if(message->sender == getnid()) { return NOT_SEND_MESSAGE_TO_NEXT_NODE; } return SEND_MESSAGE_TO_NEXT_NODE; } int ProcWatch::answerToMtUpdateInNodesList(message_struct * message, message_struct * newMessage) { if(message->sender == getnid()) { return NOT_SEND_MESSAGE_TO_NEXT_NODE; } else { int totalLogicalNodes = message->message_body.logical_nodes.total; int logicalNodesCount = 0; while(logicalNodesCount < totalLogicalNodes) { int logicalNode = message->message_body.logical_nodes.nodes[logicalNodesCount].logical_node_num; int realNode = message->message_body.logical_nodes.nodes[logicalNodesCount].real_node_num; nodesInfo->setRealNodeToLogicalNode(logicalNode, realNode); ++logicalNodesCount; } } return SEND_MESSAGE_TO_NEXT_NODE; } message_struct ProcWatch::generateBaseMessage() { message_struct message; message.magic_number = ARGON_MAGIC_NUMBER; message.sender = getnid(); return message; } message_struct ProcWatch::generateMtSelection() { message_struct message = generateBaseMessage(); message.type = MT_SELECTION; message.message_body.changes_in_cluster.cluster_state_rev = 0; message.message_body.changes_in_cluster.node_count = realNodes.entries(); int nodesTotal = realNodes.entries(); int nodesCount = 0; while(nodesCount < nodesTotal) { int currentNode = realNodes.find(nodesCount); assert(currentNode != -1); if(currentNode == getnid()) { message.message_body.changes_in_cluster.nodes[nodesCount].node_number = getnid(); message.message_body.changes_in_cluster.nodes[nodesCount].node_status = NS_ACTIVE; message.message_body.changes_in_cluster.nodes[nodesCount].node_weight = nodesInfo->getWidthOnNode(getnid()); message.message_body.changes_in_cluster.nodes[nodesCount].node_have_changes = NC_NONE; } else { message.message_body.changes_in_cluster.nodes[nodesCount].node_number = currentNode; message.message_body.changes_in_cluster.nodes[nodesCount].node_status = NS_UNAVAILIBLE; message.message_body.changes_in_cluster.nodes[nodesCount].node_weight = nodesInfo->getWidthOnNode(currentNode); message.message_body.changes_in_cluster.nodes[nodesCount].node_have_changes = NC_NONE; } ++nodesCount; } return message; } message_struct ProcWatch::generateMtClusterChanges() { message_struct message = generateBaseMessage(); message.type = MT_CLUSTER_CHANGES; message.message_body.changes_in_cluster.cluster_state_rev = clusterState->currentRev; message.message_body.changes_in_cluster.node_count = realNodes.entries(); int nodesTotal = realNodes.entries(); int nodesCount = 0; while(nodesCount < nodesTotal) { int currentNode = realNodes.find(nodesCount); assert(currentNode != -1); if(currentNode == getnid()) { message.message_body.changes_in_cluster.nodes[nodesCount].node_number = getnid(); message.message_body.changes_in_cluster.nodes[nodesCount].node_status = NS_ACTIVE; message.message_body.changes_in_cluster.nodes[nodesCount].node_weight = nodesInfo->getWidthOnNode(getnid()); message.message_body.changes_in_cluster.nodes[nodesCount].node_have_changes = NC_NONE; } else { message.message_body.changes_in_cluster.nodes[nodesCount].node_number = currentNode; message.message_body.changes_in_cluster.nodes[nodesCount].node_status = NS_UNAVAILIBLE; message.message_body.changes_in_cluster.nodes[nodesCount].node_weight = nodesInfo->getWidthOnNode(currentNode); message.message_body.changes_in_cluster.nodes[nodesCount].node_have_changes = NC_NONE; } ++nodesCount; } return message; } message_struct ProcWatch::generateMtNewActiveNode(int newActiveNode) { message_struct message = generateBaseMessage(); message.type = MT_NEW_ACTIVE_NODE; message.message_body.node_number = nodesInfo->findMinWidthRealNode(); return message; } message_struct ProcWatch::generateMtTotalProcsCount() { message_struct message = generateBaseMessage(); message.type = MT_TOTAL_PROCS_COUNT; message.message_body.proc_count = runtimeProcs.entries(); return message; } message_struct ProcWatch::generateMtTotalUpdatedProcs(int updateType) { assert((updateType == UT_FULL) || (updateType == UT_PARTIAL)); message_struct message = generateBaseMessage(); message.type = MT_TOTAL_UPDATED_PROCS; message.message_body.num_of_updates.cluster_state_rev = clusterState->currentRev; message.message_body.num_of_updates.update_type = updateType; if(updateType == UT_FULL) { message.message_body.num_of_updates.total_updates = runtimeProcs.entries(); } else if(updateType == UT_PARTIAL) { message.message_body.num_of_updates.total_updates = 0/* procsInfo->totalChangedProcs()*/; } return message; } message_struct ProcWatch::generateMtUpdateInProcsList() { message_struct message = generateBaseMessage(); message.type = MT_UPDATE_IN_PROCS_LIST; message.message_body.procs_status.cluster_state_rev = clusterState->currentRev; int procsTotal = 0; int procsCounter = 0; while(procsCounter < procsTotal) { //TODO: add info about procs ++procsCounter; } return message; } message_struct ProcWatch::generateMtUpdateInNodesList() { message_struct message = generateBaseMessage(); message.type = MT_UPDATE_IN_NODES_LIST; int nodesTotal = realNodes.entries(); message.message_body.logical_nodes.total = nodesTotal; int nodesCounter = 0; while(nodesCounter < nodesTotal) { ++nodesCounter; } return message; } int ProcWatch::messageSize(int messageType) { int size = 3 * sizeof(int); //magic_number + type + sender switch(messageType) { case MT_SELECTION: size += sizeof(changes_in_cluster_struct); break; case MT_NEW_ACTIVE_NODE: size += sizeof(int); break; case MT_LIST_OF_NODES: size += sizeof(node_list_struct); break; case MT_TOTAL_PROCS_COUNT: size += sizeof(int); break; case MT_PROCS_STATUS: size += sizeof(procs_status_struct); break; case MT_CLUSTER_CHANGES: size += sizeof(changes_in_cluster_struct); break; case MT_TOTAL_UPDATED_PROCS: size += sizeof(num_of_updates_struct); break; case MT_UPDATE_IN_PROCS_LIST: size += sizeof(procs_status_struct); break; case MT_UPDATE_IN_NODES_LIST: size += sizeof(logical_nodes_struct); break; case MT_REPLY: size += sizeof(int); break; } //return size; return sizeof(message_struct); } int ProcWatch::nextNode(int nodeNum) { log->startEvent("ProcWatch::nextNode :forNode" + toString(nodeNum)); WCValSList |
Похожие:
 | Охватывают различные подразделения, начиная с приема больного в стационаре и заканчивая его выпиской. В медицинских учреждениях работает... | | Охватывает вопросы конструирования, исследования и принципов применения интегральных микросхем |
 | Разработка кода программного продукта на основе готовых спецификаций на уровне модуля 10 | | Торговая компания, специализирующаяся в области оптовых продаж импортных и отечественных строительных материалов, средне-высокой... |
| «Разработка специального программного обеспечения для модернизации аппаратно–программного комплекса «Сапфир» | | Логико-структурная матрица по дипломному проекту «Внедрение эффективного контракта» (пример заполнения) |
| Данные гис – данные, полученные в результате геофизического исследования скважин. Синоним к термину «Каротажные данные» | | Методическая разработка предназначена для обучающихся специальности 38. 02. 01 |
| Целью освоения модуля является формирование у студентов V курса стоматологического факультета, профессиональных компетенций по способности... | | Методическая разработка на тему: «Тестовый контроль в методах и средствах личностно ориентированного обучения». Подготовила Фалько... |