std::shared_ptr<NodeData> EnvirePhysics::getInertialNode(const smurf::Inertial& inertial, const envire::core::FrameId& frame)
{
NodeData * result = new NodeData;
std::shared_ptr<NodeData> resultPtr(result);
urdf::Inertial inertialUrdf = inertial.getUrdfInertial();
result->init(inertial.getName());
result->initPrimitive(mars::interfaces::NODE_TYPE_SPHERE, mars::utils::Vector(0.1, 0.1, 0.1), inertialUrdf.mass);
result->groupID = inertial.getGroupId();
result->movable = true;
result->inertia[0][0] = inertialUrdf.ixx;
result->inertia[0][1] = inertialUrdf.ixy;
result->inertia[0][2] = inertialUrdf.ixz;
result->inertia[1][0] = inertialUrdf.ixy;
result->inertia[1][1] = inertialUrdf.iyy;
result->inertia[1][2] = inertialUrdf.iyz;
result->inertia[2][0] = inertialUrdf.ixz;
result->inertia[2][1] = inertialUrdf.iyz;
result->inertia[2][2] = inertialUrdf.izz;
result->inertia_set = true;
result->c_params.coll_bitmask = 0;
#ifdef DEBUG
LOG_DEBUG("[EnvirePhysics::getInertialNode] Inertial object's mass: %f", result->mass);
#endif
result->density = 0.0;
setPos(frame, resultPtr);
return resultPtr;
}
void MCTreeData::add(NodeSite *node) {
node->initSum();
if (_root->isFull()) {
NodeData *newRoot = new NodeData(_width, _root->level() + 1);
newRoot->add(_root);
_root = newRoot;
}
_root->add(node);
}
bool NodeToVnfmEvent::
unknown(NodeData & a_rNodeData, DashBoard & a_board)
{
gLog->WARNING("unknown");
gLog->WARNING("%-24s| unknown - [%d] [%s]",
"NodeToVnfmEvent",
a_rNodeData.GetCommand(),
a_rNodeData.GetBody().c_str());
return true;
}
NodeData testConstructors() {
NodeData A;
assert(A.getToken() == "");
assert(A.getCount() == 1);
NodeData B("hello world");
assert(B.getToken() == "hello world");
NodeData C(B);
assert(C.getToken() == "hello world");
return B;
}
//-----------------------------------------------------------------------------
void IoHandler::handleData(QByteArray *pPacket)
{
NodeData *pData = new NodeData;
pData->UpdateData(pPacket);
pData->timeStamp= QTime::currentTime();
pNodeDb->addData(pData);
emit dataReceived();
}
void OutputNodeData(NodeData & ndata)
{
NodeData::iterator nit;
int count(0);
for(nit= ndata.begin(); nit!= ndata.end(); ++nit)
{
cout<<" \""<<nit->first.c_str()<<"\" = \""<<nit->second.c_str()<<"\""<<endl;
}
cout<<"\n NodeData size: "<<ndata.size()<<"\n\n\n\n"<<endl;
}
S_UINT GetNodeDataRawDataSize(NodeData & ndata)
{
S_UINT len=0,tlen=sizeof(S_UINT);
len+=tlen + tlen;
NodeData::iterator it;
for(it=ndata.begin();it!=ndata.end();it++)
{
len+=(S_UINT)strlen(it->first.c_str())+1;
len+=(S_UINT)strlen(it->second.c_str())+1;
}
return len;
}
std::shared_ptr<NodeData> EnvirePhysics::getCollidableNode(const smurf::Collidable& collidable, const envire::core::FrameId& frame) {
NodeData * node = new NodeData;
std::shared_ptr<NodeData> nodePtr(node);
urdf::Collision collision = collidable.getCollision();
node->init(collision.name);
node->fromGeometry(collision.geometry);
node->density = 0.0;
node->mass = 0.00001;
setPos(frame, nodePtr);
node->movable = true;
node->c_params.fromSmurfCP(collidable.getContactParams());
node->groupID = collidable.getGroupId();
return nodePtr;
}
void EnvireSmurfLoader::addFloor(const vertex_descriptor ¢er)
{
NodeData data;
data.init("floorData", Vector(0,0,0));
data.initPrimitive(interfaces::NODE_TYPE_BOX, Vector(25, 25, 0.1), 0.0001);
data.movable = false;
mars::sim::PhysicsConfigMapItem::Ptr item(new mars::sim::PhysicsConfigMapItem);
data.material.transparency = 0.5;
//data.material.ambientFront = mars::utils::Color(0.0, 1.0, 0.0, 1.0);
// TODO Fix the material data is lost in the conversion from/to configmap
data.material.emissionFront = mars::utils::Color(1.0, 1.0, 1.0, 1.0);
LOG_DEBUG("Color of the Item in the addFloor: %f , %f, %f, %f", data.material.emissionFront.a , data.material.emissionFront.b, data.material.emissionFront.g, data.material.emissionFront.r );
data.toConfigMap(&(item.get()->getData()));
control->graph->addItemToFrame(control->graph->getFrameId(center), item);
}
int LimitedNodeList::updateNodeWithDataFromPacket(QSharedPointer<NLPacket> packet, SharedNodePointer sendingNode) {
QMutexLocker locker(&sendingNode->getMutex());
NodeData* linkedData = sendingNode->getLinkedData();
if (!linkedData && linkedDataCreateCallback) {
linkedDataCreateCallback(sendingNode.data());
}
if (linkedData) {
QMutexLocker linkedDataLocker(&linkedData->getMutex());
return linkedData->parseData(*packet);
}
return 0;
}
NodeData testSetters(NodeData& B) {
NodeData A("a");
A.decreaseCount();
assert(A.getCount() == 0);
int bCount = 7;
while(B.getCount() < bCount) {
B.increaseCount();
}
assert(B.getCount() == bCount);
assert(A.getToken() < B.getToken());
A = B;
assert(A.getToken() == B.getToken());
return B;
}
/**
* @brief copy constructor
* @details creates a copy of the passed in TBST
*
* @param other TBST tree to copy
*/
TBST::TBST(const TBST& other) {
root = NULL;
nodeCount = 0;
if(other.root != NULL) {
// handle root separately
assert(root == NULL); // make sure that tree is empty
// then add the root
NodeData* rootData = other.root->getData();
insert(rootData->getToken(), rootData->getCount());
// recursively copy the left and right subtrees
recursiveCopy(other.root->getLeft());
recursiveCopy(other.root->getRight());
}
else {
root = NULL;
}
}
bool CreateNodeDataByRawData(NodeData & ndata,const char *lpbuf,S_UINT bufsize)
{
if(lpbuf==NULL)
return false;
if(bufsize<sizeof(S_UINT))
return false;
S_UINT len=0,tlen=sizeof(S_UINT);
try{
const char *pend=lpbuf+bufsize;
const char *pt=lpbuf;
memmove(&len,pt,tlen);
pt+=tlen;
if(pt>pend)
return false;
if(len!=bufsize)
{
puts("Raw data of NodeData error");
return false;
}
S_UINT count;
memmove(&count,pt,tlen);
pt+=tlen;
std::string str1,str2;
S_UINT datalen;
char * data;
for(S_UINT i=0;i<count;i++)
{
str1=pt;
pt+=strlen(str1.c_str())+1;
if(pt>pend)
return true;
str2=pt;
pt+=strlen(str2.c_str())+1;
if(pt>pend)
return true;
ndata.insert(std::make_pair(str1,str2));
}
}catch(...)
{
cout<<"Exception to CreateNodeDataByRawData."<<endl;
return false;
}
return true;
}
void EnvirePhysics::itemAdded(const TypedItemAddedEvent<Item<urdf::Collision>>& e)
{
#ifdef DEBUG
LOG_DEBUG(("[EnvirePhysics::ItemAdded] urdf::Collision item received in frame *** " + e.frame + "***").c_str());
#endif
urdf::Collision collision = e.item->getData();
NodeData * node = new NodeData;
node->init(collision.name);
node->fromGeometry(collision.geometry);
node->mass = 0.00001;
node->density = 0.0;
std::shared_ptr<NodeData> nodePtr(node);
setPos(e.frame, nodePtr);
node->movable = true;
if (instantiateNode(nodePtr, e.frame))
{
#ifdef DEBUG
LOG_DEBUG(("[EnvirePhysics::ItemAdded] Smurf::Collision - Instantiated and stored the nodeInterface in frame ***" + e.frame +"***").c_str());
#endif
}
}
void EnvirePhysics::itemAdded(const TypedItemAddedEvent<PhysicsConfigMapItem>& e)
{
#ifdef DEBUG
LOG_DEBUG(("[EnvirePhysics::ItemAdded] PhysicsConfigMapItem item received in frame *** " + e.frame + "***").c_str());
#endif
PhysicsConfigMapItem::Ptr pItem = e.item;
try
{
//try to convert the item into a node Data
NodeData * node = new NodeData;
std::shared_ptr<NodeData> nodePtr(node);
if(node->fromConfigMap(&pItem->getData(), ""))
{
Transform fromOrigin;
if(originId.compare(e.frame) == 0)
{
//this special case happens when the graph only contains one frame
//and items are added to that frame. In that case aksing the graph
//for the transformation would cause an exception
fromOrigin.setTransform(TransformWithCovariance::Identity());
}
else
{
fromOrigin = control->graph->getTransform(originId, e.frame);
}
node->pos = fromOrigin.transform.translation;
node->rot = fromOrigin.transform.orientation;
if (instantiateNode(nodePtr, e.frame))
{
#ifdef DEBUG
LOG_DEBUG(("[EnvirePhysics::ItemAdded] PhysicsConfigMapItem - Instantiated and stored the nodeInterface in frame ***" + e.frame + "***").c_str());
#endif
}
}
}
catch(const UnknownTransformException& ex)
{
cerr << ex.what() << endl;
}
}
int LimitedNodeList::updateNodeWithDataFromPacket(const SharedNodePointer& matchingNode, const QByteArray &packet) {
QMutexLocker locker(&matchingNode->getMutex());
matchingNode->setLastHeardMicrostamp(usecTimestampNow());
// if this was a sequence numbered packet we should store the last seq number for
// a packet of this type for this node
PacketType packetType = packetTypeForPacket(packet);
if (SEQUENCE_NUMBERED_PACKETS.contains(packetType)) {
matchingNode->setLastSequenceNumberForPacketType(sequenceNumberFromHeader(packet, packetType), packetType);
}
NodeData* linkedData = matchingNode->getLinkedData();
if (!linkedData && linkedDataCreateCallback) {
linkedDataCreateCallback(matchingNode.data());
}
if (linkedData) {
QMutexLocker linkedDataLocker(&linkedData->getMutex());
return linkedData->parseData(packet);
}
return 0;
}
bool NodeToVnfmEvent::
perfTps(NodeData & a_rNodeData, DashBoard & a_board)
{
m_sHttpData.Clear();
gLog->DEBUG("%-24s| perf tps",
"NodeToVnfmEvent");
// vector 로 전달 된다고 합시다.
// timestamp, Tps_Title, Tps_Cnt
// Tps_Name 으로 된 값에 Sum 을 해서 보내야 하나요??
// 받아서 Board 에 Sum 만 하면 되요..
std::string timestamp;
std::string tpsTitle;
int cnt;
std::string & apiMsg = a_rNodeData.GetBody();
size_t first = 0;
size_t end = apiMsg.find('\0', first);
try
{
timestamp = apiMsg.substr(first).c_str();
first = end + 1;
end = apiMsg.find('\0', first);
tpsTitle= apiMsg.substr(first).c_str();
first = end + 1;
end = apiMsg.find('\0', first);
cnt = atoi(apiMsg.substr(first).c_str());
} catch(std::exception & e) {
gLog->WARNING("%-24s| perfTps - pasing fail",
"NodeToVnfmEvent");
return false;
}
a_board.SetTPS(timestamp, tpsTitle, cnt);
gLog->DEBUG("---- TPS : [%s] [%d]", tpsTitle.c_str(), cnt);
return true;
}
/**
* @brief Recursively query for max NodeDatas from left/right subtrees
* and compare.
* @details private recursive method. Compares maximum candidates from the root
* node, the left subtree, and the right subtree. O(n) running time.
*
* @param subroot Node pointer to the root of the subtree currently recursed on
* @return NodeData with maximum secondary value among the 3 candidates
*/
NodeData* TBST::getMaxByFrequency(Node* subroot) {
if(subroot != NULL) {
NodeData* maxData = subroot->getData(); // default max
NodeData* leftMax = NULL; NodeData* rightMax = NULL;
if(subroot->hasLeftChild())
leftMax = getMaxByFrequency(subroot->getLeft());
if(subroot->hasRightChild())
rightMax = getMaxByFrequency(subroot->getRight());
if(leftMax != NULL && maxData->getCount() < leftMax->getCount())
maxData = leftMax;
// break ties in favor of the right branch since we desire an
// increasing sort order
if(rightMax != NULL && maxData->getCount() <= rightMax->getCount())
maxData = rightMax;
return maxData;
}
else return NULL;
}
/**
* @brief Recursively query for max NodeDatas from left/right subtrees
* and compare.
* @details private recursive method. Compares minimum candidates from the root
* node, the left subtree, and the right subtree. Runs in O(n) time.
*
* @param subroot Node pointer to the root of the subtree currently recursed on
* @return NodeData with minimum secondary value among the 3 candidates
*/
NodeData* TBST::getMinByFrequency(Node* subroot) {
if(subroot != NULL) {
NodeData* minData = subroot->getData(); // default min
NodeData* leftMin = NULL; NodeData* rightMin = NULL;
if(subroot->hasLeftChild())
leftMin = getMinByFrequency(subroot->getLeft());
if(subroot->hasRightChild())
rightMin = getMinByFrequency(subroot->getRight());
// break ties in favor of the node on the left since we want increasing
// sort order
if(leftMin != NULL && minData->getCount() >= leftMin->getCount()) {
minData = leftMin;
}
if(rightMin != NULL && minData->getCount() > rightMin->getCount()) {
minData = rightMin;
}
return minData;
}
else return NULL;
}
// friend
bool Compare (const NodeData &data1, const NodeData &data2)
{
return data1.Capacity() < data2.Capacity();
}
NodeData::NodeData(const NodeData& from)
: ElementData(from.getId(), from.getTags(),
(from.hasCircularError() ? from.getCircularError() : ElementData::CIRCULAR_ERROR_EMPTY)),
_x(from._x),
_y(from._y)
{
init(from.getId(), from.getX(), from.getY(), from.getChangeset(), from.getVersion(),
from.getTimestamp(), from.getUser(), from.getUid(), from.getVisible());
}
bool NodeToVnfmEvent::
stopped(NodeData & a_rNodeData, DashBoard & a_board)
{
gLog->INFO("%-24s| stopped",
"NodeToVnfmEvent");
m_sHttpData.Clear();
std::string result;
std::string reason;
std::string prc_date;
std::string dst_yn;
try {
rabbit::document doc;
doc.parse(a_rNodeData.GetBody());
rabbit::object root = doc["BODY"];
result = root["result"].as_string();
reason = root["reason"].as_string();
prc_date= root["prc_date"].as_string();
dst_yn = root["dst_yn"].as_string();
} catch(rabbit::type_mismatch & e) {
gLog->WARNING("%-24s| stopped - type mismatch [%s]",
"NodeToVnfmEvent",
a_rNodeData.GetBody().c_str());
return false;
} catch(rabbit::parse_error & e) {
gLog->WARNING("%-24s| stopped - parse error [%s]",
"NodeToVnfmEvent",
a_rNodeData.GetBody().c_str());
return false;
} catch(...) {
gLog->WARNING("%-24s| stopped - [%s]",
"NodeToVnfmEvent",
a_rNodeData.GetBody().c_str());
return false;
}
if(result.compare("OK") != 0)
{
gLog->WARNING("%-24s| stopped - recevied response, but is not success [%s]",
"NodeToVnfmEvent",
a_rNodeData.GetBody().c_str());
return false;
}
// Encoding
rabbit::object oRoot;
rabbit::object oBody = oRoot["stopped"];
oBody["server-uuid"] = a_board.GetUUID();
oBody["timestamp"] = prc_date;
std::string body = oRoot.str();
char uriBuf[256];
sprintf(uriBuf, "%s/vnf/status/stopped", a_board.GetVnfmServiceURL());
m_sHttpData.AddLine("POST", uriBuf, "HTTP/1.1");
m_sHttpData.AddHeader("Content-Type", "application/json");
m_sHttpData.AddBody(body.c_str(), body.size());
return true;
}
/**
* @brief helper for copy-constructor
* @details recursively copy nodes from a tree pre-order
*
* @param origNode Node on the original tree to be copied over
*/
void TBST::recursiveCopy(Node* origNode) {
if(origNode != NULL) {
if(origNode->isLeaf()) {
NodeData* d = origNode->getData();
insert(d->getToken(), d->getCount());
d = NULL;
} else if(!origNode->hasLeftChild()) {
// 1: have right child, no left child
// copy the node
NodeData* d = origNode->getData();
insert(d->getToken(), d->getCount());
d = NULL;
// then recurse down and copy the right child
recursiveCopy(origNode->getRight());
} else if(!origNode->hasRightChild()) {
// 2: have left child, no right child
NodeData* d = origNode->getData();
insert(d->getToken(), d->getCount());
d = NULL;
// then recurse down and copy the left child
recursiveCopy(origNode->getLeft());
} else {
// 3: have children on both sides
NodeData* d = origNode->getData();
insert(d->getToken(), d->getCount());
d = NULL;
// then recurse down and copy both children
recursiveCopy(origNode->getLeft());
recursiveCopy(origNode->getRight());
}
}
}
void AppLayerCCNHost(Node* node, Message* msg) {
NodeData* nodeData;
nodeData = (NodeData*)node->appData.nodeData;
switch(msg->eventType)
{
/*//fujiwara//
* 1. 移動を検知したらMR(interest)を作成してPoAとHOMEにおくる
* 2. MR（data）を受け取ったら
* さらに分岐
case hand_over_kenchi //やることを書く
{
clocktype send_delayTime;
uint32_t chunk_num;
map<uint32_t, clocktype>::iterator it;
uint32_t next_msgName = global_node_data->return_MsgName();
uint32_t end_chunk_num = next_msgName % 40 + 10;
CcnMsg* ccnMsg;
ccnMsg = new CcnMsg();
ccnMsg->resent_times = 0;
ccnMsg->ccn_method = DEFAULT;
ccnMsg->msg_type = Interest;
ccnMsg->msg_name = next_msgName; //msg_nameはよくわからない 多分解析のときにわかりやすくする狙いか?
ccnMsg->msg_chunk_num = nodeData->return_lastChunkNum(ccnMsg) + 1;
ccnMsg->EncodeFullNameMsg();
ccnMsg->sender_node_id = node->nodeId; // node->nodeid = このメッセージを送るノードのID
ccnMsg->source_node_id = source_node_id; //ここを変更 source_node_id = 送信先ノード(現状サーバが一個しかとれない仕様……)
ccnMsg->payload_length = 30; //ペイロードはヘッダを除いたデータ部分の大きさ
ccnMsg->hops_limit = 20;
ccnMsg->content_type = CommonData;
ccnMsg->end_chunk_num = end_chunk_num;
ccnMsg->interest_genTime = node->getNodeTime();
ccnMsg->data_genTime = node->getNodeTime();
nodeData->set_lastChunkNum(ccnMsg); //chunkの最後の値を記録 よくわからない 必要?
nodeData->reqMapInput(node, ccnMsg); //msg_full_nameとノードのシミュレーション時間のペアを記録する
nodeData->fibSend_DEFAULT(node, ccnMsg);//送信
nodeData->make_reTransMsg(node, ccnMsg);//再送の話 よくわからない 必要か?
}*/
case MSG_APP_FromTransDataReceived: // データ受け取り時
{
TransportToAppDataReceived *openResult;
openResult = (TransportToAppDataReceived*) MESSAGE_ReturnInfo(msg);
APP_TcpCloseConnection(node, openResult->connectionId);
// msgからccnメッセージを取得
// ccnメッセージを処理
// データ送信の場合、TCP接続要求を送る
// msgのキーからccnメッセージを取り出す
CcnMsg* ccnMsg;
ccnMsg = nodeData->BufferRetrieve_Host(node, msg);
Node* remote_node;
NodeData* remote_nodeData;
remote_node = MAPPING_GetNodePtrFromHash(GlobalNodeData::nodeHash, ccnMsg->previous_node_id);
remote_nodeData = (NodeData*)remote_node->appData.nodeData;
// パケットロストによる取得エラー
if(nodeData->node_role + remote_nodeData->node_role == CLIENT + RELAY_NODE) {
if((rand() * 100.0) < (nodeData->error_rate * RAND_MAX)) {
//printf("packet lost occured at %d->%d\n", remote_node->nodeId, node->nodeId);
//nodeData->statData->packet_lostTimes++;
if(ccnMsg->ccn_method == PROPOSAL &&
(ccnMsg->msg_type == Interest || ccnMsg->msg_type == Data)){
} else if(ccnMsg->ccn_method == PRIOR) {
nodeData->statData->packet_lostTimes++; // this is not lost but unacquired
break;
} else {
break;
}
}
}
nodeData->StatisticalInfo_recvCcnMsg(node, ccnMsg);
// ホップカウント(loop検出用)
if(!ccnMsg->checkHopCount()) {
printf("hop count is over\n");
break;
}
switch(ccnMsg->ccn_method)
{
case DEFAULT:
case DEFAULT_FAST:
{
switch(ccnMsg->msg_type) {
case Interest:
{
// ソースノードまで転送
// PITに名前を記録(msg_full_name)
// ソースノードならDataパケットを返送
// 返送する際はPITを参照
if(nodeData->pitInsert_DEFAULT(node, ccnMsg)) {
// PITで登録済み
delete ccnMsg;
break;
}
if(nodeData->csSend(node, ccnMsg) == true) {
// キャッシュヒット
if(ccnMsg->content_type == CommonData) {
nodeData->StatisticalInfo_cacheHit(node, ccnMsg);
}
break;
}
// ソースノード到着
if(ccnMsg->source_node_id == node->nodeId) {
// InterestをDataに変換
nodeData->convertInterest_intoData(ccnMsg);
// Dataの送信時間設定
clocktype send_delayTime;
if(ccnMsg->content_type == VideoData) {
map<uint32_t, clocktype>::iterator it;
it = nodeData->dataGenerateTime_map.find(ccnMsg->msg_chunk_num);
send_delayTime = it->second - node->getNodeTime();
} else {
send_delayTime = 0;
}
// PITで設定時間に則った送信
if(send_delayTime < 0) {
nodeData->pitSend_DEFAULT(node, ccnMsg);
} else {
nodeData->pitSend_DEFAULT(node, ccnMsg, send_delayTime);
}
}
else {
// FIBによるフォワーディング
nodeData->fibSend_DEFAULT(node, ccnMsg);
}
break;
} // Interest
case Data:
{
//if(ccnMsg->content_type == CommonData) {
// nodeData->statData->commonPacket_recv++;
// nodeData->statData->commonPacketSize_recv += ccnMsg->payload_length;
//} else if(ccnMsg->content_type == VideoData) {
// nodeData->statData->videoPacket_recv++;
// nodeData->statData->videoPacketSize_recv += ccnMsg->payload_length;
//}
if(nodeData->reqMapSearch(node, ccnMsg)) {
if(ccnMsg->content_type == CommonData) {
nodeData->statData->request_commonPacket_recv++;
nodeData->statData->request_commonPacketSize_recv += ccnMsg->payload_length;
} else if(ccnMsg->content_type == VideoData) {
nodeData->statData->request_videoPacket_recv++;
nodeData->statData->request_videoPacketSize_recv += ccnMsg->payload_length;
}
// PROPOSAL再送での誤爆回避
if(nodeData->ccn_method == PROPOSAL) {
if(ccnMsg->content_type == VideoData) {
nodeData->Cancel_reTransMsg(node, ccnMsg->msg_full_name);
nodeData->recvRequestData(node, ccnMsg); // Statistical data
delete ccnMsg;
break;
}
}
// 再送パケットは次のパケットを要求しないため、ここで終了
if(ccnMsg->resent_times > 0) {
if(ccnMsg->content_type == VideoData) {
if(nodeData->ccn_method == DEFAULT) {
nodeData->Cancel_reTransMsg(node, ccnMsg->msg_full_name);
nodeData->recvRequestData(node, ccnMsg); // Statistical data
delete ccnMsg;
break;
}
else if(nodeData->ccn_method == DEFAULT_FAST) {
nodeData->Cancel_reTransMsg(node, ccnMsg->msg_full_name);
nodeData->recvRequestData(node, ccnMsg); // Statistical data
delete ccnMsg;
break;
}
}
}
// 未取得chunkを取得
if(nodeData->ccn_method == DEFAULT_FAST) {
if(ccnMsg->content_type == VideoData) {
if(ccnMsg->msg_chunk_num > nodeData->return_lastRecvMsg(ccnMsg) + 1) {
CcnMsg* t_ccnMsg;
t_ccnMsg = nodeData->NewCcnMsg(ccnMsg);
t_ccnMsg->msg_chunk_num = nodeData->return_lastRecvMsg(ccnMsg) + 1;
t_ccnMsg->EncodeFullNameMsg();
t_ccnMsg->payload_length = 30;
t_ccnMsg->resent_times = 1;
t_ccnMsg->msg_type = Interest;
t_ccnMsg->hops_limit = 20;
nodeData->reqMapSearch(node, t_ccnMsg);
nodeData->reqMapInput(node, t_ccnMsg);
nodeData->Cancel_reTransMsg(node, t_ccnMsg->msg_full_name);
nodeData->make_reTransMsg(node, t_ccnMsg);
Node* source_node;
map<uint32_t, clocktype>::iterator it;
source_node = MAPPING_GetNodePtrFromHash(GlobalNodeData::nodeHash, source_node_id);
nodeData->source_nodeData = (NodeData*)source_node->appData.nodeData;
NodeData* source_nodeData;
source_nodeData = nodeData->source_nodeData;
it = source_nodeData->dataGenerateTime_map.find(t_ccnMsg->msg_chunk_num);
t_ccnMsg->data_genTime = it->second;
nodeData->set_windowSize(node, t_ccnMsg);
nodeData->fibSend(node, t_ccnMsg);
}
}
}
nodeData->release_windowSize(node, ccnMsg);
nodeData->set_lastRecvMsg(ccnMsg);
nodeData->Cancel_reTransMsg(node, ccnMsg->msg_full_name);
nodeData->recvRequestData(node, ccnMsg); // Statistical data
if(ccnMsg->end_chunk_num < nodeData->return_lastChunkNum(ccnMsg) + 1) {
delete ccnMsg;
break;
}
// クライアントにData到着
ccnMsg->msg_type = Interest;
ccnMsg->msg_chunk_num = nodeData->return_lastChunkNum(ccnMsg) + 1;
ccnMsg->EncodeFullNameMsg();
ccnMsg->resent_times = 0;
ccnMsg->payload_length = 30;
ccnMsg->hops_limit = 20;
ccnMsg->interest_genTime = node->getNodeTime();
map<uint32_t, clocktype>::iterator it;
it = nodeData->source_nodeData->dataGenerateTime_map.find(ccnMsg->msg_chunk_num);
ccnMsg->data_genTime = it->second;
nodeData->set_lastChunkNum(ccnMsg);
nodeData->set_windowSize(node, ccnMsg);
nodeData->make_reTransMsg(node, ccnMsg);
nodeData->reqMapInput(node, ccnMsg);
nodeData->fibSend(node, ccnMsg);
break;
}
nodeData->csInsert_DEFAULT(node, ccnMsg);
nodeData->pitSend_DEFAULT(node, ccnMsg);
break;
}
default:
{
ERROR_ReportError("Undefined msg type\n");
}
}
break;
}
case PRIOR:
{
switch(ccnMsg->msg_type) {
case Interest:
{
// ソースノードまで転送
// PITに名前を記録(msg_name)
// ソースノードならDataパケットを返送
// またDataパケットを一定時間ごとに生成・転送
// 返送する際はPITを参照
if(nodeData->csSend(node, ccnMsg) == true) {
// キャッシュヒット
nodeData->StatisticalInfo_cacheHit(node, ccnMsg);
break;
}
if(nodeData->pitInsert_PRIOR(node, ccnMsg)) {
// PITで登録済み
delete ccnMsg;
break;
}
if(ccnMsg->source_node_id == node->nodeId) {
nodeData->convertInterest_intoData(ccnMsg);
nodeData->set_lastChunkNum(ccnMsg);
APP_SetTimer(node, APP_CCN_CLIENT, 0, APP_CCN_LISTEN_PORT, APP_TIMER_DATA_SEND_PKT, 0 * MILLI_SECOND);
}
else {
nodeData->fibSend_PRIOR(node, ccnMsg);
}
break;
}
case Data:
{
if(nodeData->reqMapSearch_PRIOR(node, ccnMsg)) {
nodeData->recvRequestData(node, ccnMsg); // Statistical data
delete ccnMsg;
break;
}
nodeData->pitSend_PRIOR(node, ccnMsg);
break;
}
default:
ERROR_ReportError("Undefined msg type\n");
}
break;
}
case PROPOSAL:
{
switch(ccnMsg->msg_type) {
case Interest:
{
nodeData->fibModInsert(node, ccnMsg, ccnMsg->previous_node_id);
if(nodeData->pitInsert_PROPOSAL(node, ccnMsg)) {
// PITで登録済み
delete ccnMsg;
break;
}
if(ccnMsg->source_node_id == node->nodeId) {
nodeData->set_lastChunkNum(ccnMsg);
nodeData->convertInterest_intoData(ccnMsg);
nodeData->pitSend_PROPOSAL(node, ccnMsg);
// プッシュ配信登録
APP_SetTimer(node, APP_CCN_CLIENT, 0, APP_CCN_LISTEN_PORT, APP_TIMER_fakeINTEREST_SEND_PKT, 0 * MILLI_SECOND);
}
else {
nodeData->fibSend_PROPOSAL(node, ccnMsg);
}
break;
}
case Data:
{
if(nodeData->reqMapSearch(node, ccnMsg)) {
nodeData->recvRequestData(node, ccnMsg); // Statistical data
// プッシュ配信登録済みクライアントであることを記録
nodeData->reqModMapInput(node, ccnMsg);
delete ccnMsg;
break;
}
nodeData->pitSend_PROPOSAL(node, ccnMsg);
break;
}
case fakeInterest:
{
nodeData->pitModInsert(node, ccnMsg);
nodeData->csModInsert(node, ccnMsg);
if(nodeData->node_role == CLIENT)
if(ccnMsg->msg_name != msg_videoData_name + node->nodeId%3)
printf("[node%d][msg%lu] fuckfuckfuck %d %d\n",node->nodeId, ccnMsg->msg_full_name, ccnMsg->msg_name, ccnMsg->msg_chunk_num);
if(nodeData->reqModMapSearch(node, ccnMsg)) { // クライアント到着
nodeData->recvRequestData(node, ccnMsg); // Statistical data
nodeData->recvModMapInsert(node, ccnMsg);
nodeData->convertFakeInterest_intoFakeData(ccnMsg);
nodeData->pitModSend(node, ccnMsg);
// 未取得chunkを取得
if(ccnMsg->msg_chunk_num > nodeData->return_lastRecvMsg(ccnMsg) + 1) {
CcnMsg* ccnMsg;
ccnMsg = new CcnMsg();
ccnMsg->resent_times = 1;
ccnMsg->ccn_method = DEFAULT;
ccnMsg->msg_type = Interest;
ccnMsg->msg_name = msg_videoData_name + node->nodeId % 3;
ccnMsg->msg_chunk_num = nodeData->return_lastRecvMsg(ccnMsg) + 1;
ccnMsg->EncodeFullNameMsg();
ccnMsg->sender_node_id = node->nodeId;
ccnMsg->source_node_id = source_node_id;
ccnMsg->payload_length = 30;
ccnMsg->hops_limit = 20;
ccnMsg->interest_genTime = node->getNodeTime();
ccnMsg->content_type = VideoData;
ccnMsg->end_chunk_num = UINT16_MAX;
Node* source_node;
map<uint32_t, clocktype>::iterator it;
source_node = MAPPING_GetNodePtrFromHash(GlobalNodeData::nodeHash, source_node_id);
nodeData->source_nodeData = (NodeData*)source_node->appData.nodeData;
NodeData* source_nodeData;
source_nodeData = nodeData->source_nodeData;
it = source_nodeData->dataGenerateTime_map.find(ccnMsg->msg_chunk_num);
ccnMsg->data_genTime = it->second;
nodeData->reqMapSearch(node, ccnMsg);
nodeData->set_windowSize(node, ccnMsg);
nodeData->reqMapInput(node, ccnMsg);
nodeData->make_reTransMsg(node, ccnMsg);
nodeData->fibSend(node, ccnMsg);
} else if (ccnMsg->msg_chunk_num == nodeData->return_lastRecvMsg(ccnMsg) + 1){
//printf("Got actual packet\n");
} else {
}
nodeData->set_lastRecvMsg(ccnMsg);
break;
}
if(nodeData->fibModSend(node, ccnMsg)) {
delete ccnMsg;
break;
}
break;
}
case fakeData:
{
// クライアントにデータ到着
if(ccnMsg->source_node_id == node->nodeId) {
delete ccnMsg;
break;
}
nodeData->pitModSend(node, ccnMsg);
break;
}
default:
ERROR_ReportError("Undefined msg type\n");
}
break;
}
default:
ERROR_ReportError("Undefined ccn_method\n");
}
break;
}
case MSG_APP_FromTransOpenResult: // TCPでpassive open処理が終了
//if(node->nodeId == 1) printf("openResult->connectionId: %lu\n", openResult->connectionId);
break;
case MSG_APP_FromTransListenResult: // コネクション要求待機状態を確立
//if(node->nodeId == 1) printf("openResult->connectionId: %lu\n", openResult->connectionId);
break;
case MSG_APP_TimerExpired:
{
AppTimer* timer;
timer = (AppTimer *)MESSAGE_ReturnInfo(msg);
switch(timer->type) {
case APP_TIMER_RE_SEND_PKT:
nodeData->send_reTransMsg(node, timer->connectionId);
break;
}
break;
}
case MSG_APP_FromTransCloseResult:
break;
default:
printf("msg->eventType = %d\n", msg->eventType);
ERROR_ReportError("msg->eventType error: undefined eventType\n");
}
MESSAGE_Free(node, msg);
}
void AppCCNHostFinalize(Node* node, AppInfo* appInfo) {
NodeData* nodeData = (NodeData *)appInfo->appDetail;
if(node->nodeId == 1) nodeData->StatisticalInfo_print_totalNodeInfo(node, global_node_data->maximumActiveNodeNum);
}
void AppCCNNodeInit(Node* node, NodeRole role, const NodeInput *nodeInput)
{
char str[MAX_STRING_LENGTH];
BOOL wasFound = FALSE;
if(global_node_data == NULL) {
global_node_data = new GlobalNodeData();
}
global_node_data->setMaxNodeId(node->nodeId);
// nodeDataポインタをnodeに保存
// nodeDataはノードでのccnMsgの取り扱いを担う
NodeData* nodeData;
nodeData = (NodeData*) node->appData.nodeData;
if(nodeData == NULL) {
nodeData = new NodeData(node, nodeInput);
node->appData.nodeData = nodeData;
}
nodeData->node_role = role;
//FIB input
nodeData->fibMapInput(node, "fib.conf");
// ハンドラの登録
APP_RegisterNewApp(node, APP_CCN_HOST, nodeData);
// TCP受信準備
Address node_addr;
node_addr = MAPPING_GetDefaultInterfaceAddressInfoFromNodeId(node, node->nodeId, NETWORK_IPV4);
APP_TcpServerListen(node, APP_CCN_HOST, node_addr, (short) APP_CCN_LISTEN_PORT);
std::ofstream ofs(nodeData->name_logFile.c_str());
ofs << "node->getNodeTime()" << ", " << "generateToRecv_Delay" << ", " << "sendToRecv_Delay" << ", " << "ccnMsg->msg_chunk_num" << std::endl;
// ノードの役割ごとに初期設定
switch(role)
{
// クライアント
case CLIENT:
{
// timer message送信
// ライブストリーミング
if(nodeData->ccn_method != NO_VIDEO) {
APP_SetTimer(node, APP_CCN_CLIENT, 0, APP_CCN_LISTEN_PORT, APP_TIMER_SEND_PKT, 800 * MILLI_SECOND);
}
// 通常コンテンツ
APP_SetTimer(node, APP_CCN_CLIENT, 0, APP_CCN_LISTEN_PORT, APP_TIMER_REGULAR_SEND_PKT, 1 * SECOND + 10 * MILLI_SECOND * node->nodeId);
break;
}
// 中継ノード
case RELAY_NODE:
{
break;
}
// ソースノード
case SERVER:
{
source_node_id = node->nodeId;
uint32_t chunk_num;
clocktype generateTime;
generateTime = 0;
double randNum;
for(chunk_num = 0; chunk_num < 100000; chunk_num++) {
generateTime += nodeData->return_packetRandomGenerateTime();
nodeData->dataGenerateTime_map.insert(pair<uint32_t, clocktype>(chunk_num, generateTime));
randNum = (double) (1.0 / (RAND_MAX + 1.0)) * rand();
nodeData->randomNum_map.insert(pair<uint32_t, double>(chunk_num, randNum));
}
break;
}
default:
ERROR_ReportError("");
}
}
void AppLayerCCNClient(Node* node, Message* msg) {
NodeData* nodeData;
nodeData = (NodeData*)node->appData.nodeData;
Node* source_node;
source_node = MAPPING_GetNodePtrFromHash(GlobalNodeData::nodeHash, source_node_id);
nodeData->source_nodeData = (NodeData*)source_node->appData.nodeData;
NodeData* source_nodeData;
source_nodeData = nodeData->source_nodeData;
switch(msg->eventType)
{
// タイマーメッセージ
case MSG_APP_TimerExpired: // タイマーメッセージ
{
AppTimer* timer;
timer = (AppTimer *)MESSAGE_ReturnInfo(msg);
// timer messageの種類によって処理を分ける
switch(timer->type)
{
case APP_TIMER_SEND_PKT:
{
printf("この表示がなければ、APP_TIMER_SEND_PKTはビデオストリーミング確定 ");
clocktype send_delayTime;
uint32_t chunk_num;
map<uint32_t, clocktype>::iterator it;
chunk_num = 0;
do {
chunk_num++;
it = source_nodeData->dataGenerateTime_map.find(chunk_num);
if(it == source_nodeData->dataGenerateTime_map.end()) {
ERROR_ReportError("dataGenerateTime_map error\n");
}
send_delayTime = it->second - node->getNodeTime();
} while(send_delayTime < 0);
nodeData->set_lastChunkNum(msg_videoData_name + node->nodeId % 3, chunk_num - 1);
nodeData->set_lastRecvMsg(msg_videoData_name + node->nodeId % 3, chunk_num - 1);
CcnMsg* ccnMsg;
do {
ccnMsg = new CcnMsg();
ccnMsg->ccn_method = nodeData->ccn_method;
ccnMsg->resent_times = 0;
ccnMsg->msg_type = Interest;
ccnMsg->msg_name = msg_videoData_name + node->nodeId % 3;
ccnMsg->msg_chunk_num = nodeData->return_lastChunkNum(ccnMsg) + 1;
ccnMsg->EncodeFullNameMsg();
ccnMsg->sender_node_id = node->nodeId;
ccnMsg->source_node_id = source_node_id;
ccnMsg->payload_length = 30;
ccnMsg->hops_limit = 20;
ccnMsg->interest_genTime = node->getNodeTime();
ccnMsg->content_type = VideoData;
ccnMsg->end_chunk_num = UINT32_MAX;
it = source_nodeData->dataGenerateTime_map.find(ccnMsg->msg_chunk_num);
ccnMsg->data_genTime = it->second;
nodeData->set_lastChunkNum(ccnMsg);
nodeData->fibSend(node, ccnMsg);
if(ccnMsg->ccn_method == DEFAULT) {
nodeData->make_reTransMsg(node, ccnMsg);
nodeData->set_lastRecvMsg(msg_videoData_name + node->nodeId % 3, UINT32_MAX - 3);
nodeData->reqMapInput(node, ccnMsg);
}
else if(ccnMsg->ccn_method == DEFAULT_FAST) {
nodeData->make_reTransMsg(node, ccnMsg);
nodeData->set_lastRecvMsg(msg_videoData_name + node->nodeId % 3, UINT32_MAX - 3);
nodeData->reqMapInput(node, ccnMsg);
}
else if(ccnMsg->ccn_method == PRIOR) {
nodeData->reqMapInput_PRIOR(node, ccnMsg);
break;
}
else if(ccnMsg->ccn_method == PROPOSAL) {
nodeData->set_lastRecvMsg(msg_videoData_name + node->nodeId % 3, UINT32_MAX - 1);
nodeData->reqMapInput(node, ccnMsg);
//printf("[node%d][msg%d] sendInterest\n", node->nodeId, ccnMsg->msg_name);
break;
}
} while(nodeData->set_windowSize(node, ccnMsg));
break;
} // APP_TIMER_SEND_PKT
case APP_TIMER_DATA_SEND_PKT:
{
printf("この表示がなければ、APP_TIMER_DATA_SEND_PKTはいらない子。てかどうやってここはいるんだ… ");
CcnMsg* ccnMsg;
for(int i = 0; i < 3; i++) {
ccnMsg = new CcnMsg();
ccnMsg->resent_times = 0;
ccnMsg->ccn_method = PRIOR;
ccnMsg->msg_type = Data;
ccnMsg->msg_name = msg_videoData_name + i;
ccnMsg->msg_chunk_num = nodeData->return_lastChunkNum(ccnMsg) + 1;
ccnMsg->EncodeFullNameMsg();
ccnMsg->sender_node_id = node->nodeId;
ccnMsg->source_node_id = source_node_id;
ccnMsg->payload_length = nodeData->tcp_mss;
ccnMsg->hops_limit = 20;
ccnMsg->interest_genTime = node->getNodeTime();
ccnMsg->content_type = VideoData;
ccnMsg->end_chunk_num = UINT32_MAX;
map<uint32_t, clocktype>::iterator it;
it = nodeData->dataGenerateTime_map.find(ccnMsg->msg_chunk_num);
ccnMsg->data_genTime = it->second;
clocktype send_delayTime;
send_delayTime = ccnMsg->data_genTime - node->getNodeTime();
if(send_delayTime < 0) send_delayTime = 0;
nodeData->set_lastChunkNum(ccnMsg);
nodeData->pitSend_PRIOR(node, nodeData->NewCcnMsg(ccnMsg), send_delayTime);
APP_SetTimer(node, APP_CCN_CLIENT, 0, APP_CCN_LISTEN_PORT, APP_TIMER_DATA_SEND_PKT, send_delayTime);
}
delete ccnMsg;
break;
} // APP_TIMER_DATA_SEND_PKT
case APP_TIMER_fakeINTEREST_SEND_PKT:
{
printf("この表示がなければ、APP_TIMER_fakeINTEREST_SEND_PKTはいらない子。てかここどうやって入るんだ… ");
// 動画の配信分をすべて出す
CcnMsg* ccnMsg;
for(int i = 0; i < 3; i++) {
ccnMsg = new CcnMsg();
ccnMsg->resent_times = 0;
ccnMsg->ccn_method = PROPOSAL;
ccnMsg->msg_type = fakeInterest;
ccnMsg->msg_name = msg_videoData_name + i;
ccnMsg->msg_chunk_num = nodeData->return_lastChunkNum(ccnMsg) + 1;
ccnMsg->EncodeFullNameMsg();
ccnMsg->sender_node_id = node->nodeId;
ccnMsg->source_node_id = source_node_id;
ccnMsg->payload_length = nodeData->tcp_mss;
ccnMsg->hops_limit = 20;
ccnMsg->interest_genTime = node->getNodeTime();
ccnMsg->content_type = VideoData;
ccnMsg->end_chunk_num = UINT32_MAX;
map<uint32_t, clocktype>::iterator it;
it = nodeData->dataGenerateTime_map.find(ccnMsg->msg_chunk_num);
ccnMsg->data_genTime = it->second;
clocktype send_delayTime;
send_delayTime = ccnMsg->data_genTime - node->getNodeTime();
if(send_delayTime < 0) send_delayTime = 0;
nodeData->set_lastChunkNum(ccnMsg);
nodeData->fibModSend(node, nodeData->NewCcnMsg(ccnMsg), send_delayTime);
APP_SetTimer(node, APP_CCN_CLIENT, 0, APP_CCN_LISTEN_PORT, APP_TIMER_fakeINTEREST_SEND_PKT, send_delayTime);
}
delete ccnMsg;
break;
} // APP_TIMER_fakeINTEREST_SEND_PKT
case APP_TIMER_REGULAR_SEND_PKT:
{
//printf("この表示は 予想ではたくさんでる。APP_TIMER_REGULAR_SEND_PKT\n");
clocktype send_delayTime;
uint32_t chunk_num;
map<uint32_t, clocktype>::iterator it;
uint32_t next_msgName = global_node_data->return_MsgName();
uint32_t end_chunk_num = next_msgName % 40 + 10;
CcnMsg* ccnMsg;
do {
ccnMsg = new CcnMsg();
ccnMsg->resent_times = 0;
ccnMsg->ccn_method = DEFAULT;
ccnMsg->msg_type = Interest;
ccnMsg->msg_name = next_msgName;
ccnMsg->msg_chunk_num = nodeData->return_lastChunkNum(ccnMsg) + 1;
ccnMsg->EncodeFullNameMsg();
ccnMsg->sender_node_id = node->nodeId;
ccnMsg->source_node_id = source_node_id;
ccnMsg->payload_length = 30;
ccnMsg->hops_limit = 20;
ccnMsg->content_type = CommonData;
ccnMsg->end_chunk_num = end_chunk_num;
ccnMsg->interest_genTime = node->getNodeTime();
ccnMsg->data_genTime = node->getNodeTime();
nodeData->set_lastChunkNum(ccnMsg);
nodeData->reqMapInput(node, ccnMsg);
nodeData->fibSend_DEFAULT(node, ccnMsg);
nodeData->make_reTransMsg(node, ccnMsg);
if(ccnMsg->msg_chunk_num > ccnMsg->end_chunk_num) break;
} while(nodeData->set_windowSize(node, ccnMsg));
APP_SetTimer(node, APP_CCN_CLIENT, 0, APP_CCN_LISTEN_PORT, APP_TIMER_REGULAR_SEND_PKT, nodeData->commonPacketGenerateTime);
break;
} // APP_TIMER_REGULAR_SEND_PKT
default:
ERROR_ReportError("Undefined timer type\n");
}
break;
} // MSG_APP_TimerExpired
case MSG_APP_FromTransOpenResult: // TCPでactive open処理が完了
{
// データ送信処理
// 送信データの操作は出来る限りHostの処理にしておく
// ここでは送信処理だけ
TransportToAppOpenResult *openResult;
openResult = (TransportToAppOpenResult*) MESSAGE_ReturnInfo(msg);
//TCPコネクションが不成立時(失敗)
if (openResult->connectionId < 0)
{
char buf[MAX_STRING_LENGTH];
ctoa(node->getNodeTime(),buf);
node->appData.numAppTcpFailure++;
break;
}
// バッファーからccnメッセージを取り出し
CcnMsg* ccnMsg;
ccnMsg = nodeData->BufferRetrieve_Client(node, msg);
nodeData->StatisticalInfo_sendCcnMsg(node, ccnMsg);
ccnMsg->App_TcpSendCcnMsg(node, msg);
break;
} // MSG_APP_FromTransOpenResult
case MSG_APP_FromTransDataSent: // TCPでデータ転送終了
TransportToAppDataSent *openResult;
openResult = (TransportToAppDataSent*) MESSAGE_ReturnInfo(msg);
APP_TcpCloseConnection(node, openResult->connectionId);
break;
case MSG_APP_FromTransCloseResult:
break;
default:
ERROR_ReportError("msg->eventType error: undefined eventType\n");
}
MESSAGE_Free(node, msg);
}
bool NodeToVnfmEvent::
subscriber(NodeData & a_rNodeData, DashBoard & a_board)
{
gLog->DEBUG("%-24s| subscriber",
"NodeToVnfmEvent");
m_sHttpData.Clear();
std::string prc_date;
std::string dst_yn;
try {
rabbit::document doc;
doc.parse(a_rNodeData.GetBody());
rabbit::object root = doc["BODY"];
prc_date= root["prc_date"].as_string();
dst_yn = root["dst_yn"].as_string();
} catch(rabbit::type_mismatch & e) {
gLog->WARNING("%-24s| stopped - type mismatch [%s]",
"NodeToVnfmEvent",
a_rNodeData.GetBody().c_str());
return false;
} catch(rabbit::parse_error & e) {
gLog->WARNING("%-24s| stopped - parse error [%s]",
"NodeToVnfmEvent",
a_rNodeData.GetBody().c_str());
return false;
} catch(...) {
gLog->WARNING("%-24s| stopped - [%s]",
"NodeToVnfmEvent",
a_rNodeData.GetBody().c_str());
return false;
}
// Encoding
char callbackUri[URI_MAX_SIZE];
sprintf(callbackUri, "%s/vnf/notification/lifecycle", a_board.GetMyURL());
rabbit::object oRoot;
rabbit::object oBody = oRoot["subscriber"];
oBody["server-uuid"] = a_board.GetUUID();
oBody["name"] = "VNF";
oBody["notification_type"] = "VNF Lifecycle Change";
oBody["callback_uri"] = callbackUri;
std::string body = oRoot.str();
char uriBuf[URI_MAX_SIZE];
sprintf(uriBuf, "%s/vnf/subscriber", a_board.GetVnfmServiceURL());
m_sHttpData.AddLine("POST", uriBuf, "HTTP/1.1");
m_sHttpData.AddHeader("Content-Type", "application/json");
m_sHttpData.AddBody(body.c_str(), body.size());
return true;
}
bool NodeToVnfmEvent::
event(NodeData & a_rNodeData, DashBoard & a_board)
{
gLog->DEBUG("%-24s| event",
"NodeToVnfmEvent");
m_sHttpData.Clear();
std::string event_type;
std::string timestamp;
std::string code;
std::string severity;
std::string probable_cause;
std::string additional_text;
int coresponse_action_cnt = 0;
std::string coresponse_action;
try {
rabbit::document doc;
doc.parse(a_rNodeData.GetBody());
rabbit::object root = doc["BODY"];
event_type = root["event_type"].as_string();
timestamp = root["prc_date"].as_string();
code = root["code"].as_string();
severity = root["perceived_severity"].as_string();
probable_cause = root["probable_cause"].as_string();
additional_text = root["additional_text"].as_string();
if(root["coresponse_action"].is_null() == false)
{
coresponse_action_cnt = root["coresponse_action_cnt"].as_int();
coresponse_action = root["coresponse_action"].as_string();
}
} catch(rabbit::type_mismatch & e) {
gLog->WARNING("%-24s| event - type mismatch [%s]",
"NodeToVnfmEvent",
a_rNodeData.GetBody().c_str());
return false;
} catch(rabbit::parse_error & e) {
gLog->WARNING("%-24s| event - parse error [%s]",
"NodeToVnfmEvent",
a_rNodeData.GetBody().c_str());
return false;
} catch(...) {
gLog->WARNING("%-24s| event - [%s]",
"NodeToVnfmEvent",
a_rNodeData.GetBody().c_str());
return false;
}
rabbit::object oRoot;
rabbit::object oBody = oRoot["event"];
oBody["server-uuid"] = a_board.GetUUID();
oBody["event_type"] = event_type;
oBody["timestamp"] = timestamp;
oBody["perceived_severity"] = severity;
oBody["additional_text"] = additional_text;
oBody["alarm_code"] = code;
if(coresponse_action.size() > 0)
{
if(coresponse_action_cnt == 0)
oBody["coresponse_action_cnt"] = 1;
else
oBody["coresponse_action_cnt"] = coresponse_action_cnt;
oBody["coresponse_action"] = coresponse_action;
}
std::string body = oRoot.str();
char uriBuf[URI_MAX_SIZE];
sprintf(uriBuf, "%s/vnf/event", a_board.GetVnfmServiceURL());
m_sHttpData.AddLine("POST", uriBuf, "HTTP/1.1");
m_sHttpData.AddHeader("Content-Type", "application/json");
m_sHttpData.AddBody(body.c_str(), body.size());
return true;
}
bool NodeToVnfmEvent::
perf(NodeData & a_rNodeData, DashBoard & a_board)
{
m_sHttpData.Clear();
gLog->DEBUG("%-24s| perf",
"NodeToVnfmEvent");
std::string & body = a_rNodeData.GetBody();
if(body.size() <= 0)
{
gLog->WARNING("%-24s| perf - no body",
"NodeToVnfmEvent");
return false;
}
gLog->DEBUG("%-24s| perf - [%s]",
"NodeToVnfmEvent",
body.c_str());
try
{
rabbit::document doc;
doc.parse(body);
// 1) CPU
rabbit::array cpu_list = doc["BODY"]["RSC_GRP_04"]["LIST"];
std::string key =
(cpu_list.at(0)).as_string();
std::string cpu_usage =
doc["BODY"]["RSC_GRP_04"][key.c_str()]["usage"].as_string();
a_board.SetCPU(cpu_usage);
// 2) MEM
rabbit::array mem_list = doc["BODY"]["RSC_GRP_02"]["LIST"];
key =
(mem_list.at(0)).as_string();
std::string mem_usage =
doc["BODY"]["RSC_GRP_02"][key.c_str()]["usage"].as_string();
a_board.SetMEM(mem_usage);
// 4) NET
std::string net_rx;
std::string net_tx;
rabbit::array net_list = doc["BODY"]["RSC_GRP_11"]["LIST"];
for(auto nLoop = 0u; nLoop < net_list.size(); ++nLoop)
{
key = net_list.at(nLoop).as_string();
net_rx = doc["BODY"]["RSC_GRP_11"][key.c_str()]["RX"].as_string();
net_tx = doc["BODY"]["RSC_GRP_11"][key.c_str()]["TX"].as_string();
a_board.SetNET(key, net_rx, net_tx);
}
// 5) TIME
std::string timestamp = doc["BODY"]["time"].as_string();
std::string dst_yn = doc["BODY"]["dst_yn"].as_string();
a_board.SetTIME(timestamp, dst_yn);
// 3) DISK
unsigned long long disk_total = 0;
unsigned long long disk_used = 0;
rabbit::array disk_list = doc["BODY"]["RSC_GRP_05"]["LIST"];
for(auto nLoop = 0u; nLoop < disk_list.size(); ++nLoop)
{
key = disk_list.at(nLoop).as_string();
disk_total += atoll(doc["BODY"]["RSC_GRP_05"][key.c_str()]["total"].as_string().c_str());
disk_used += atoll(doc["BODY"]["RSC_GRP_05"][key.c_str()]["used"].as_string().c_str());
}
unsigned long long disk_used_percent = 0;
if(disk_total == 0)
disk_used_percent = 0;
else
disk_used_percent = (disk_used / disk_total) * 100;
key = "total";
std::string disk_usage = std::to_string(disk_used_percent);
a_board.SetDISK(key, disk_usage);
} catch(rabbit::type_mismatch & e) {
gLog->WARNING("%-24s| perf - type mismatch [%s]",
"NodeToVnfmEvent",
body.c_str());
return false;
} catch(rabbit::parse_error & e) {
gLog->WARNING("%-24s| perf - parse error [%s]",
"NodeToVnfmEvent",
body.c_str());
return false;
} catch(...) {
gLog->WARNING("%-24s| perf - [%s]",
"NodeToVnfmEvent",
body.c_str());
return false;
}
return true;
}
