C++ NetworkNode类代码示例

void Server::loadServers(const std::string & path) {
    // The add server lambda function:
    auto addServer = [] (const std::string & host, const std::string & service) {
        try {
            NetworkNode node;
            node.Initialize(host, service);
            Network::AddNode(node);
        } catch (std::exception & e) {
            std::cerr << "[Server::loadServers::addServer] catch => std::exception" << std::endl;
            std::cerr << "+ WHAT: " << e.what() << std::endl;
        }
    };
    // Clear the current nodes:
    Network::ClearNodes();
    // Add the local node to the table:
    auto & portNumber = Options::Get(Options::PortNumberKey);
    addServer(LOCAL_HOST, portNumber);
    // Load the lines inside the servers configuration file:
    std::string line, address, port;
    std::ifstream file(path);
    while (std::getline(file, line)) {
        // This is a Comma-separated values file:
        std::stringstream sline(line);
        bool ok = std::getline(sline, address, ',') &&
                  std::getline(sline, port, ',') &&
                  IsPortNumber(port);
        if (ok) {
            addServer(address, port);
        } else {
            std::cerr << "[Server::loadServers] Wrong line!" << std::endl;
            std::cerr << "+ FILE: " << path << std::endl;
            std::cerr << "+ LINE: " << line << std::endl;
        }
    }
}

double
MacroCellUrbanAreaChannelRealization::GetPathLoss (void)
{
  /*
   * According to  ---  insert standard 3gpp ---
   * the Path Loss Model For Urban Environment is
   * L = I + 37.6log10(R)
   * R, in kilometers, is the distance between two nodes
   * I = 128.1 at 2GHz
   */
  double distance;
  double externalWallAttenuation = 20; //[dB]

  NetworkNode* src = GetSourceNode ();
  NetworkNode* dst = GetDestinationNode ();

  distance = src->GetMobilityModel ()->GetAbsolutePosition ()->GetDistance (
		  dst->GetMobilityModel ()->GetAbsolutePosition ());

  /*
  if (GetSourceNode ()->GetNodeType () == NetworkNode::TYPE_UE
		  && GetDestinationNode ()->GetNodeType () == NetworkNode::TYPE_ENODEB)
    {
	  UserEquipment* ue = (UserEquipment*) GetSourceNode ();
	  ENodeB* enb = (ENodeB*) GetDestinationNode ();

	  distance =  ue->GetMobilityModel ()->GetAbsolutePosition ()->GetDistance (enb->GetMobilityModel ()->GetAbsolutePosition ());
    }

  else if (GetDestinationNode ()->GetNodeType () == NetworkNode::TYPE_UE
		  && GetSourceNode ()->GetNodeType () == NetworkNode::TYPE_ENODEB)
    {
	  UserEquipment* ue = (UserEquipment*) GetDestinationNode ();
	  ENodeB* enb = (ENodeB*) GetSourceNode ();

	  distance =  ue->GetMobilityModel ()->GetAbsolutePosition ()->GetDistance (enb->GetMobilityModel ()->GetAbsolutePosition ());
    }
  */

  m_pathLoss = 128.1 + (37.6 * log10 (distance * 0.001));

  UserEquipment* ue;
  if (GetSourceNode ()->GetNodeType () == NetworkNode::TYPE_UE)
    {
	  ue = (UserEquipment*) GetSourceNode ();
    }
  else
   {
	  ue = (UserEquipment*) GetDestinationNode ();
   }

  if ( ue->IsIndoor() )
  {
	  m_pathLoss = m_pathLoss + externalWallAttenuation;
  }


  return m_pathLoss;
}

/**
 * Given a NodeInfoMsg inserts the node into NetworkNode database.
 * @param session can be null
 * Returns true if new node inserted, false if already present
 * Delete the message
 */
bool NodeNetworkSystem::_addNetworkNode(Session* session, NodeInfoMsg* msg) {
	if (_DEBUG)
		cout << "NodeNetworkSystem::_addNetworkNode" << endl;

	bool retval = false;
	NetworkNode* connectedNode = NetworkNode::getNodeById(msg->getId());
	if (connectedNode == NULL) {
		/* The connected node is unknown. Add it */
		retval = true;
		if (_DEBUG)
			cout
					<< "NodeNetworkSystem::_addNetworkNode: creating a new NetworkNode"
					<< endl;
		switch (msg->getNodeType()) {
		case NODETYPE_CAMERA:
			connectedNode = NetworkNode::addCamera(msg->getId(),
					msg->getAmAddress(), msg->getIpAddress(),
					msg->getServerPort());
			break;
		case NODETYPE_COOPERATOR:
			connectedNode = NetworkNode::addCooperator(msg->getId());
			break;
		default:
			if (_DEBUG)
				cerr
						<< "NodeNetworkSystem::_addNetworkNode: Error! Notification of a type "
						<< msg->getNodeType() << " node!" << endl;
			return false;
		}
		if (_DEBUG) {
			cout
					<< "NodeNetworkSystem::_addNetworkNode: Network Topology updated "
					<< endl;
			NetworkNode::printNetwork();
		}
	}
	if (session) {
		connectedNode->setSession(session);
	}
	if (connectedNode->getType() == NODETYPE_COOPERATOR) {
		switch (NetworkNode::getMyself()->getType()) {
		case NODETYPE_CAMERA: {
			_offloadingManager->addCooperator(connectedNode);
			CoopInfoMsg* infoMsg = new CoopInfoMsg(NetworkNode::getMyself(),
					NetworkNode::getSink(), LINKTYPE_TCP,
					_offloadingManager->getCooperatorsIds());
			sendMessage(infoMsg);
			break;
		}
		default:
			break;
		}
	}

	delete msg;

	return retval;
}

void Network::buildExecutionNetwork() {
  E_DEBUG(ENetwork, "building execution network");
  clearExecutionNetwork();

  // 1- First build the visible network
  E_DEBUG(ENetwork, "  1- build visible network");
  E_DEBUG_INDENT;

  FractalNode* executionNetworkRoot = visibleNetwork<FractalNode>(_generator);

  FNodeVector visibleNodes = depthFirstSearch(executionNetworkRoot);

  // 2- Expand all the nodes of this first graph
  E_DEBUG_OUTDENT;
  E_DEBUG(ENetwork, "  2- expand nodes");
  E_DEBUG_INDENT;

  expandNodes(visibleNodes);

  // 3- connect the expanded versions of the nodes together
  E_DEBUG_OUTDENT;
  E_DEBUG(ENetwork, "  3- connect expanded network");
  E_DEBUG_INDENT;
  connectExpandedNodes(visibleNodes);

  // 4- construct our "clean" execution network and clean up the FractalNodes
  E_DEBUG_OUTDENT;
  E_DEBUG(ENetwork, "  4- construct final network");
  E_DEBUG_INDENT;
  FNodeVector expandedNodes = depthFirstSearch(executionNetworkRoot->expanded);
  E_DEBUG(ENetwork, "num connected expanded nodes: " << expandedNodes.size());
  map<FractalNode*, NetworkNode*> falgoMap; // expanded → final network node

  for (int i=0; i<(int)expandedNodes.size(); i++) {
    falgoMap[expandedNodes[i]] = new NetworkNode(expandedNodes[i]->algorithm());
  }
  for (int i=0; i<(int)expandedNodes.size(); i++) {
    NetworkNode* parent = falgoMap[expandedNodes[i]];
    vector<FractalNode*> children = expandedNodes[i]->children();
    for (int j=0; j<(int)children.size(); j++) {
      E_DEBUG(ENetwork, "  -  " << parent->algorithm()->name() << " → " << falgoMap[children[j]]->algorithm()->name());
      parent->addChild(falgoMap[children[j]]);
    }
  }

  _executionNetworkRoot = falgoMap[executionNetworkRoot->expanded];

  // delete the FractalNodes which we just used temporarily for building the network
  E_DEBUG(ENetwork, "cleaning up temp visible fractal nodes");
  for (int i=0; i<(int)visibleNodes.size(); i++) delete visibleNodes[i];
  E_DEBUG(ENetwork, "cleaning up temp expanded fractal nodes");
  for (int i=0; i<(int)expandedNodes.size(); i++) delete expandedNodes[i];

  E_DEBUG_OUTDENT;
  E_DEBUG(ENetwork, "execution network ok");

}

NetworkNode *NetworkNode::create(
	pubnub::context *pb,
	const string &channel)
{
	NetworkNode *b = new NetworkNode();
	if (b && b->initialize(pb, channel)) {
		b->autorelease();
		return b;
	}
	CC_SAFE_DELETE(b);
	return nullptr;
}

void Network::topologicalSortExecutionNetwork() {
  // Note: we don't need to do a full-fledged topological sort here, as we do not
  // have any DAG, we actually have a dependency tree. This way we can just do a
  // depth-first search, with ref-counting to account for diamond shapes in the tree.
  // this is similar to the wavefront design pattern used in parallelization

  // Using DFS here also has the advantage that it makes as much as possible use
  // of cache locality

  // 1- get all the nodes and count the number of refs they have
  NodeVector nodes = depthFirstSearch(_executionNetworkRoot);
  map<NetworkNode*, int> refs;

  // this initialization should be useless, but let's do it anyway for clarity
  for (int i=0; i<(int)nodes.size(); i++) refs[nodes[i]] = 0;

  // count the number of refs for each node
  for (int i=0; i<(int)nodes.size(); i++) {
    const NodeVector& children = nodes[i]->children();
    for (int j=0; j<(int)children.size(); j++) {
      refs[children[j]] += 1;
    }
  }

  // 2- do DFS again, manually this time and only visit node which have no refs anymore
  _toposortedNetwork.clear();

  NodeStack toVisit;
  toVisit.push(_executionNetworkRoot);
  refs[_executionNetworkRoot] = 1;

  while (!toVisit.empty()) {
    NetworkNode* currentNode = toVisit.top();
    toVisit.pop();

    if (--refs[currentNode] == 0) {
      _toposortedNetwork.push_back(currentNode->algorithm()); // keep this node, it is good

      const NodeVector& children = currentNode->children();
      for (int i=0; i<(int)children.size(); i++) {
        toVisit.push(children[i]);
      }
    }
  }

  E_DEBUG(ENetwork, "-------------------------------------------------------------------------------------------");
  for (int i=0; i<(int)_toposortedNetwork.size(); i++) {
    E_DEBUG_NONL(ENetwork, " → " << _toposortedNetwork[i]->name());
  }
  E_DEBUG(ENetwork, ""); // for adding a newline
  E_DEBUG(ENetwork, "-------------------------------------------------------------------------------------------");
}

/**
 * Send message on the correct interface
 */
void NodeNetworkSystem::sendMessage(Message* msg) {
	if (!msg) {
		if (_DEBUG)
			cerr << "NodeNetworkSystem::sendMessage: Empty message" << endl;

		return;
	}

	NetworkNode* dst = msg->getDst();
	if (!dst) {
		if (_DEBUG)
			cerr << "NodeNetworkSystem::sendMessage: Empty destination" << endl;
		delete msg;
		return;
	}

	if (msg->getType() == MESSAGETYPE_DATA_ATC
			|| msg->getType() == MESSAGETYPE_DATA_CTA) {
		boost::mutex::scoped_lock lock(_countMutex);
		_queuedMessages++;
		_gpios[5]->setValue(BlackLib::high); //Set transmission pin
		lock.unlock();
	}

	switch (msg->getLinkType()) {
	case LINKTYPE_TCP: {
		Session* ses = dst->getSession();
		if (!ses) {
			if (_DEBUG)
				cerr << "NodeNetworkSystem::sendMessage: Empty session" << endl;
			delete msg;
			return;
		}
		ses->writeMessage(msg);
		break;
	}
	case LINKTYPE_TELOS: {
		_telosbRadioSystem->writeMessage(msg);
		break;
	}
	default: {
		if (_DEBUG)
			cout << "NodeNetworkSystem::sendMessage: Not yet implemented"
					<< endl;
		delete msg;
		break;
	}
	}

}

void
NetworkManager::SelectTargetNode (UserEquipment* ue)
{
   NetworkNode* targetNode = ue->GetTargetNode ();

   if (targetNode->GetProtocolStack ()->GetRrcEntity ()->
		   GetHandoverEntity ()->CheckHandoverNeed (ue))
     {
	   NetworkNode* newTagertNode =
			   targetNode->GetProtocolStack ()->GetRrcEntity ()->
			   GetHandoverEntity ()->GetHoManager ()->m_target;

	   ue->SetTargetNode (newTagertNode);
     }
}

 static std::string getTarget( NetworkNode& iNode )
 {
     std::string result;
     iNode.getTarget( result );
     
     return result;
 }

    static std::string getNodeType( NetworkNode& iNode )
    {
        std::string result;
        iNode.getNodeType( result );

        return result;
    }

bool RoutingAlg<Point, HoleType>::GreedyRouting() {
	NetworkNode<Point>	currentNode  = StartNode;
	NetworkNode<Point>	previousNode = StartNode;
	string				closestNeighborName;

	Path.push_back(StartNode);
	while(!currentNode.HasNeighbor(DestinationNode.GetName()) && currentNode.GetName() != DestinationNode.GetName()){
		if(previousNode.FindClosestNeighborToNode(DestinationNode.GetName(), closestNeighborName)
		&& NetworkPtr -> GetNodeByName(closestNeighborName, currentNode)){
			Path.push_back(currentNode);
				previousNode = currentNode;
		}
		else
			return false;
	}
	Path.push_back(DestinationNode);
	return true;
}

void NetworkPlan::findCriticalPaths(NetworkNode* cur) {
	// Статическая переменная, инициализируется при первом вызове функции.
	// Является счётчиком путей.
	static int pathNum = 0;
	bool isFirst = true;
	NetworkNode* tmpNode = NULL;
	const vector<NetworkNode*>* nodes = cur->getOutgoingNodes();
	vector<NetworkNode*>::iterator itr;
	vector<NetworkNode*>::iterator itr2;
	int size = nodes->size();

	_critPaths->at(pathNum)->push_back(cur);

	for (int i = 0; i < size; i++) {
		tmpNode = nodes->at(i);

		if (tmpNode->getReserve() == 0) {
			if (isFirst) {
				findCriticalPaths(tmpNode);

				isFirst = false;
			} else {
				_critPaths->push_back(new vector<NetworkNode*>());

				// Получаем итератор на начало текущего пути.
				itr = _critPaths->at(pathNum)->begin();
				// Находим в пути текущий узел...
				itr2 = find(itr, _critPaths->at(pathNum)->end(), cur);

				// ... и копируем вершины в новый путь дублирующуюся часть.
				while (itr++ != (itr2 + 1)) {
					_critPaths->at(pathNum + 1)->push_back(*(itr - 1));
				}

				pathNum++;

				findCriticalPaths(tmpNode);
			}
		}
	}
}

void StopNodePacket::processPacket(Application* app, TCPSocket* client) const {
	NetworkNode* node = app->getNetworkNode();

	//Did we already receive this one?
	vector<Packet*> rcvPackets = node->getReceivedPackets();
	bool found = false;
	for (auto itr = rcvPackets.begin(); itr != rcvPackets.end(); itr++) {
		if (*this == **itr) {
			//the order "this then itr" is crucial, else the equality check will not work proper!
			found = true;
			break;
		}
	}

	if (!found) {
		if (targetNodeId == node->getOwnId()) {
			node->stop();
		}
		else {

			if (!app->getNetworkNode()->send(targetNodeId, this)) {
				// we don't know the target, broadcast packet
				node->sendToNeighbors(this, node->getNodeId(client));
			}
		}
	}
}

/**
 * A client component has connected. Notify the server this node
 */
void NodeNetworkSystem::clientConnectHandler(Session* session) {
	if (_DEBUG)
		cout << "NodeNetworkSystem::clientConnectHandler" << endl;

	NetworkNode* serverNode = NetworkNode::getNodeBySession(session);
	NetworkNode* myself = NetworkNode::getMyself();

	NodeInfoMsg* msg = new NodeInfoMsg(myself, serverNode, LINKTYPE_TCP,
			myself->getId(), myself->getAmAddr(),
			session->getSocket()->local_endpoint().address().to_string(),
			session->getSocket()->local_endpoint().port(), myself->getType());

	session->writeMessage(msg);

	if (myself->getType() == NODETYPE_CAMERA) {
		CoopInfoMsg* infoMsg = new CoopInfoMsg(NetworkNode::getMyself(),
				NetworkNode::getSink(), LINKTYPE_TCP,
				_offloadingManager->getCooperatorsIds());
		sendMessage(infoMsg);
	}

}

    static dict getConnectionByIndex( NetworkNode& iNode, size_t iIndex )
    {
        std::string inputName, connectedNodeName, connectedOutputName;

        iNode.getConnection( iIndex, inputName, connectedNodeName,
                             connectedOutputName );

        dict ret;
        ret["inputName"] = inputName;
        ret["connectedNodeName"] = connectedNodeName;
        ret["connectedOuputName"] = connectedOutputName;

        return ret;
    }