Esempio n. 1
0
void XMLMessage::setBean(XMLMessageBean* bean)
{
	char *xmlText = bean->encode();
 	if (xmlText != NULL)
	{
		ByteArray bytes(xmlText, strlen(xmlText));
		setPayload(&bytes);
	}
	else
		setPayload(NULL);
}
Esempio n. 2
0
Message::Message(quint32 pNo, Member* sender, quint32 cmd, QByteArray payload)
{
    setPacketNo(pNo);
    setSender(sender);
    setCommand(cmd);
    setPayload(payload);
}
void MigrationVerifyActor::handleVerifyRequest(const idgs::actor::ActorMessagePtr& msg) {
  pb::MigrationVerifyRequest* request = NULL;
  if (msg->getPayload()) {
    request = dynamic_cast<pb::MigrationVerifyRequest*>(msg->getPayload().get());
  }

  if (request && request->has_schema_name() && request->has_store_name()) {
    auto datastore = idgs::store::idgs_store_module()->getDataStore();
    auto store = datastore->getStore(request->schema_name(), request->store_name());
    if (!store) {
      LOG(ERROR) << "store " << request->schema_name() << "." << request->store_name() << " is not found.";
      auto payload = std::make_shared<pb::MigrationVerifyResponse>();
      payload->set_result_code(static_cast<int32_t>(RC_STORE_NOT_FOUND));
      auto respMsg = msg->createResponse();
      respMsg->setOperationName("VERIFY_RESPONSE");
      respMsg->setPayload(payload);
      idgs::actor::sendMessage(respMsg);
      return;
    }

    if (store->getStoreConfig()->getStoreConfig().partition_type() != idgs::store::pb::PARTITION_TABLE) {
      LOG(ERROR) << "store " << request->schema_name() << "." << request->store_name() << " is not a partition store.";
      auto payload = std::make_shared<pb::MigrationVerifyResponse>();
      payload->set_result_code(static_cast<int32_t>(RC_STORE_NOT_FOUND));
      auto respMsg = msg->createResponse();
      respMsg->setOperationName("VERIFY_RESPONSE");
      respMsg->setPayload(payload);
      idgs::actor::sendMessage(respMsg);
      return;
    }
  }

  clientMsg = msg;
  auto& members = idgs_application()->getMemberManager()->getMemberTable();
  auto it = members.begin();
  for (; it != members.end(); ++ it) {
    if (it->isLocalStore() && (it->getState() == idgs::pb::MS_PREPARED || it->getState() == idgs::pb::MS_ACTIVE)) {
      auto reqMsg = createActorMessage();
      reqMsg->setOperationName("LOCAL_VERIFY_REQUEST");
      reqMsg->setDestMemberId(it->getId());
      reqMsg->setDestActorId(actorId);
      reqMsg->setPayload(msg->getPayload());
      idgs::actor::sendMessage(reqMsg);
      ++ memberSize;
    }
  }
}
Esempio n. 4
0
Packet::Packet(string packetData){
// Parse the packet into the object

	stringstream deserializer(packetData); 

	string type;

	deserializer >> type;
	
	string d;
	string t;
	string dateTime;

	deserializer >> d;
	deserializer >> t;
	
	stringstream dateTimeStream;
	dateTimeStream << d << " " << t;
	dateTime = dateTimeStream.str(); 

	const char * timeBuffer =dateTime.c_str();

	tm date;
	strptime(timeBuffer, "%Y-%m-%d %H:%M:%S", &date);	
	
	time_t packetTime = mktime(&date);
	setTimeSent(packetTime);
	
	int life;
	deserializer >> life;
	setLifeTime(life);

	int pno;
	deserializer >> pno;	
	setPacketNumber(pno);
	
	int hop;
	deserializer >> hop;
	hop++;
	setHopCount(hop);

	string src;
	deserializer >> src;
	setSourceAddress(src);
	
	string dest;
	deserializer >> dest;
	setDestinationAddress(dest);

	stringstream payloadStream;
	payloadStream << deserializer.rdbuf();
	
	string pay = payloadStream.str();
	pay = pay.substr(1, pay.length());
	setPayload(pay);	

	
}
Esempio n. 5
0
// rxPacket - Function to read the frame received.
void XBeeLib::rxPacket()
{
	int index;
	
	int size;
	int length;
	int payloadPosition;
	
	if(getCoordinatorEnabled() == 1){
		size = 8;
		length = 22;
		payloadPosition = 14;
	}
	else{
		size = 1;
		length = 9;
		payloadPosition = 8;
	}
	
	clearReceived();
	char frame[size];
	index = 0;
	
	if(Serial.available() > length){
		Serial.println();
		for(int i = 0; i <= length; i++){
			if((i >= payloadPosition) && (i < length)){
				frame[index] = Serial.read();
				addReceived((String)((char)frame[index]));
				Serial.print(frame[index], HEX);
				Serial.print(" ");
				index++;			
			}
			else{
			    Serial.print(Serial.read(), HEX);
			    Serial.print(" ");
			}
		}
		
	    Serial.print("\n<<< ");
		Serial.println(getReceived());
		
		if(getCoordinatorEnabled() == 0){
		    if(getReceived() == "r"){
		      //setConfigure();
		    }
		    if(getReceived() == "s"){
		      //setSleepMode();
		    }
		    if(getReceived() == "t"){
				setPayload(getStatus());
				txRequest(getPayloadAddress());
		    }
		}
	}
}
Esempio n. 6
0
/*!
  \brief Create a Smart Poster record based on the record passed
  through the argument.

  Internalizes and parses the payload of the original record.
  */
NdefNfcSpRecord::NdefNfcSpRecord(const QNdefRecord &other)
    : QNdefRecord(QNdefRecord::NfcRtd, "Sp"),
      recordUri(NULL),
      recordAction(NULL),
      recordSize(NULL),
      recordType(NULL),
      recordImage(NULL)
{
    setPayload(other.payload());
}
Esempio n. 7
0
/*!
  \brief Create an empty Smart Poster (Sp) record.

  Note that in order to write a Smart Poster to a tag,
  you have to at least add the URL. An empty Smart Poster
  record is not valid according to the specs.
  */
NdefNfcSpRecord::NdefNfcSpRecord()
    : QNdefRecord(QNdefRecord::NfcRtd, "Sp"),
      recordUri(NULL),
      recordAction(NULL),
      recordSize(NULL),
      recordType(NULL),
      recordImage(NULL)
{
    setPayload(QByteArray(0, char(0)));
}
Esempio n. 8
0
// Note; doit-on passer en dynamique ???
//       si l'o
anbMessage createIDMessage 		(unsigned char txID)
{
	anbMessage msg; 
	setTxID (&msg, txID);
	setRxID (&msg, _BDCAST_ADDR);
	setType (&msg, ID_MSG);
	setSize (&msg, 0);
	setPayload (&msg, NULL); 

	return msg; 
}
Esempio n. 9
0
anbMessage createACKMessage 	(unsigned char txID, unsigned char rxID)
{
	anbMessage msg; 
	setTxID (&msg, txID);
	setRxID (&msg, rxID);
	setType (&msg, ACK_MSG);
	setSize (&msg, 0);
	setPayload (&msg, NULL); 

	return msg; 
}
DeviceInfoPacket::DeviceInfoPacket(int width, int height, String userID) {

	mWidth=width;
	mHeight=height;
	mUserID=userID;


	sprintf(buffer, "%4d%4d0123456789", 720, 1280);
	header=new PacketHeader(DEVICE_INFO, 18);
	setHeader(header);
	setPayload((byte*)buffer);
}
Esempio n. 11
0
anbMessage createDATAMessage  (unsigned char txID, unsigned char rxID, 
															 char* payload, unsigned char payloadSize)
{
	anbMessage msg; 
	setTxID (&msg, txID);
	setRxID (&msg, rxID);
	setType (&msg, DATA_MSG);
	setSize (&msg, payloadSize);
	setPayload (&msg, payload);

	return msg; 
}
Esempio n. 12
0
/*!
    Sets the locale of the text record to \a locale.
*/
void QNdefNfcTextRecord::setLocale(const QString &locale)
{
    QByteArray p = payload();

    quint8 status = p.isEmpty() ? 0 : p.at(0);

    quint8 codeLength = status & 0x3f;

    quint8 newStatus = (status & 0xd0) | locale.length();

    p[0] = newStatus;
    p.replace(1, codeLength, locale.toAscii());

    setPayload(p);
}
Esempio n. 13
0
Message::Message()
{
    d = new MessageData;
    qRegisterMetaType<Message>("Message");
    setType( "" );
    setPayload( "" );
    setSenderID( 0 );
    setGroupID( 0 );
    setSeconds( 0 );
    setUseconds( 0 );
    setBridgeID( 0 );
    setHist( false );
    setName( "Unknown" );
    setSender( 0 );
}
/*! \sa PacketProcessor
 */
Packet& PacketProcessor::buildIPPacket(string p_DestinationIP, string p_SourceIP, string p_Payload)
{

    //store the arguments
    m_DestinationIP = p_DestinationIP;
    m_SourceIP = p_SourceIP;
    m_Payload = p_Payload;    
   
    //set version
    m_PacketBuffer[0] = (unsigned char)setSubField((unsigned)m_PacketBuffer[0], VERSION, 7, 4);

    //set standard header length
    m_PacketBuffer[0] = (unsigned char)setSubField((unsigned)m_PacketBuffer[0], IHL, 3, 0);

    //set the second field to zero (DSCP[7-2] and ECN[1-0])

    //set identification
    setMultipleFields(&m_PacketBuffer[5], m_Identification++, SHORT);
    //set flags
    clearBit(&m_PacketBuffer[6], 7); //reserved
    clearBit(&m_PacketBuffer[6], 6); //Don't fragment DF
    clearBit(&m_PacketBuffer[6], 5); //More fragments MF
    //set fragment offset

    //set TTL
    m_PacketBuffer[8] = TTL;
    //set Protocol
    m_PacketBuffer[9] = PROTOCOL;

    //set source IP
    m_Converter.ipToUChar(m_SourceIP, &m_PacketBuffer[12]);
    //set destination IP
    m_Converter.ipToUChar(m_DestinationIP, &m_PacketBuffer[16]);


    //set paylod and packet length
    setMultipleFields(&m_PacketBuffer[3], setPayload(&m_PacketBuffer[20]), SHORT);    

    addCheckSum(m_PacketBuffer);
    //set the IP packet into the frame
    m_Frame.setPDU(m_PacketBuffer);
    resetPacketBuffer();

    return m_Frame;

}
Esempio n. 15
0
HardwareState::HardwareState() {
	// set initial states and values of modules
	setEnergy((MIN_PROPER_VOLTAGE + MAX_PROPER_VOLTAGE)/2);
	setEnergyCurrent(MAX_PROPER_CURRENT);
	setEnergyStatus(MODULE_ON);

	setTemperature((MAX_PROPER_TEMPERATURE + MIN_PROPER_TEMPERATURE)/2);
	setTemperatureStatus(MODULE_ON);

	setPayload(1);
	setPayloadStatus(MODULE_STANDBY);
	setSband(1);
	setSbandStatus(MODULE_STANDBY);
	setSolarPanels(1);
	setSolarPanelsStatus(MODULE_ON);
	setThermalControl(1);
	setThermalControlStatus(MODULE_STANDBY);
}
Esempio n. 16
0
void EthernetFrame::build(MacAddress& dstMac, MacAddress& srcMac, NetworkData* newPayload /* = 0 */,
	const PayloadType newPayloadType /* = Eth_MaxType */) {

	ACE_TRACE("EthernetFrame::build");
	throwIfInitialized();
	setInitialized_(true);

	if ( newPayload ) 
		setUnitLength(estimate_length(newPayload->getUnitLength(), preambleLength_, typeLen_));
	else
		setUnitLength(estimate_length(0, preambleLength_, typeLen_));
	
	if (preambleLength_ == LinuxTap) { setPreambleType(newPayloadType); }
	setDstAddr(dstMac);
	setSrcAddr(srcMac);
	setEtherType(newPayloadType);
	if ( newPayload) setPayload(newPayload);
}
Esempio n. 17
0
Message::Message( QString type, QByteArray payload, quint64 senderID, quint64 groupID,
                    quint32 seconds, quint32 useconds, quint32 bridgeID, bool hist ,
                    QString name, Target* sender )
{
    d = new MessageData;
    qRegisterMetaType<Message>("Message");

    setType( type );
    setPayload( payload );
    setSenderID( senderID );
    setGroupID( groupID );
    setSeconds( seconds );
    setUseconds( useconds );
    setBridgeID( bridgeID );
    setHist( hist );
    setName( name );
    setSender( sender );
}
void PairStoreDelegateRddPartition::handleRddTransform(const idgs::actor::ActorMessagePtr& msg) {
  if (!active) {
    active = true;
  }

  transform();

  rddLocal->setPartitionState(partition, TRANSFORM_COMPLETE);
  shared_ptr<RddResponse> response = make_shared<RddResponse>();
  response->set_partition(partition);
  response->set_result_code(RRC_SUCCESS);

  auto respMsg = createActorMessage();
  respMsg->setDestActorId(rddLocal->getRddId().actor_id());
  respMsg->setDestMemberId(rddLocal->getRddId().member_id());
  respMsg->setOperationName(PARTITION_TRANSFORM_COMPLETE);
  respMsg->setPayload(response);
  sendMessage(respMsg);
}
Esempio n. 19
0
/*!
    Sets the enconding of the contents to \a encoding.
*/
void QNdefNfcTextRecord::setEncoding(Encoding encoding)
{
    QByteArray p = payload();

    quint8 status = p.isEmpty() ? 0 : p.at(0);

    QString string = text();

    if (encoding == Utf8)
        status &= ~0x80;
    else
        status |= 0x80;

    p[0] = status;

    setPayload(p);

    setText(string);
}
Esempio n. 20
0
/*!
    Sets the contents of the text record to \a text.
*/
void QNdefNfcTextRecord::setText(const QString text)
{
    if (payload().isEmpty())
        setLocale(QLocale().name());

    QByteArray p = payload();

    quint8 status = p.at(0);

    bool utf16 = status & 0x80;
    quint8 codeLength = status & 0x3f;

    p.truncate(1 + codeLength);

    QTextCodec *codec = QTextCodec::codecForName(utf16 ? "UTF-16BE" : "UTF-8");

    p += codec->fromUnicode(text);

    setPayload(p);
}
void PairStoreDelegateRddPartition::handleActionRequest(const idgs::actor::ActorMessagePtr& msg) {
  ActionRequest* request = dynamic_cast<ActionRequest*>(msg->getPayload().get());
  DVLOG(3) << getPartitionName() << " run " << request->action_op_name() << " action";

  shared_ptr<ActionResponse> response = make_shared<ActionResponse>();
  response->set_action_id(request->action_id());
  response->set_partition(partition);
  ActionMgr& actionMgr = *idgs_rdd_module()->getActionManager();
  const ActionPtr& action = actionMgr.get(request->action_op_name());

  RddResultCode code = RRC_SUCCESS;
  if (action.get()) {
    if (rddLocal->isReplicatedRdd() && partition > 0) {
      code = RRC_SUCCESS;
    } else {
      action::ActionContext ctx;
      if (ctx.initContext(&msg, &rddLocal->getKeyTemplate(), &rddLocal->getValueTemplate())) {
        code = action->action(&ctx, this);
        if (code == RRC_SUCCESS) {
          auto& result = ctx.getPartitionResult();
          for (int32_t i = 0; i < result.size(); ++i) {
            response->add_action_value(result[i].toString());
          }
        }
      } else {
        code = RRC_INVALID_ACTION_PARAM;
      }
    }
  } else {
    LOG(ERROR)<< "action " << request->action_op_name() << " is not registered.";
    code = RRC_ACTION_NOT_FOUND;
  }

  response->set_result_code(code);

  VLOG(2) << getPartitionName() << " process " << request->action_op_name() << " action done.";
  auto respMsg = msg->createResponse();
  respMsg->setOperationName(RDD_ACTION_RESPONSE);
  respMsg->setPayload(response);
  idgs::actor::sendMessage(respMsg);
}
Esempio n. 22
0
anbMessage unserializeMessage (char* msgBuffer)
{
	anbMessage msg;
	char *visitor = msgBuffer; 
	
	setTxID (&msg, (unsigned char) *visitor);
	++visitor;	
	setRxID (&msg, (unsigned char) *visitor);
	++visitor;	
	setType (&msg, (unsigned char) *visitor);
	++visitor;	
	setSize (&msg, (unsigned char) *visitor); 

	if (getSize (&msg) != 0)
	{
		createPayload (&msg, getSize (&msg)); 
		++visitor; 
		setPayload (&msg, visitor); 	
	}
	return msg; 
}
void MigrationVerifyActor::handleVerifyResponse(const idgs::actor::ActorMessagePtr& msg) {
  auto response = dynamic_cast<pb::MigrationVerifyResponse*>(msg->getPayload().get());
  memberData.insert(std::pair<int32_t, pb::MemberMigrationData>(msg->getSourceMemberId(), response->member_data(0)));

  if (memberData.size() == memberSize) {
    auto payload = std::make_shared<pb::MigrationVerifyResponse>();
    payload->set_result_code(static_cast<int32_t>(RC_SUCCESS));
    auto it = memberData.begin();
    for (; it != memberData.end(); ++ it) {
      payload->add_member_data()->CopyFrom(it->second);
    }

    auto respMsg = clientMsg->createResponse();
    respMsg->setOperationName("VERIFY_RESPONSE");
    respMsg->setPayload(payload);

    idgs::actor::sendMessage(respMsg);

    memberData.clear();
    memberSize = 0;
  }
}
Esempio n. 24
0
// copy constructor
SFPacket::SFPacket(const SFPacket &pPacket) {
    length = pPacket.getLength();
    type = pPacket.getType();
    seqno = pPacket.getSeqno();
    setPayload(pPacket.getPayload(), length);
}
void MigrationVerifyActor::handleLocalVerifyRequest(const idgs::actor::ActorMessagePtr& msg) {
  pb::MigrationVerifyRequest* request = NULL;
  if (msg->getPayload()) {
    request = dynamic_cast<pb::MigrationVerifyRequest*>(msg->getPayload().get());
  }

  auto datastore = idgs::store::idgs_store_module()->getDataStore();
  std::vector<idgs::store::StorePtr> stores;
  if (request && request->has_schema_name() && request->has_store_name()) {
    auto store = datastore->getStore(request->schema_name(), request->store_name());
    stores.push_back(store);
  } else {
    datastore->getStores(stores);
  }

  auto app = idgs_application();
  auto cluster = app->getClusterFramework();
  auto pcnt = cluster->getPartitionCount();
  auto bkcnt = cluster->getClusterConfig()->max_replica_count() - 1;
  auto local = cluster->getLocalMember()->getId();
  auto partitionMgr = app->getPartitionManager();

  auto payload = std::make_shared<pb::MigrationVerifyResponse>();
  payload->set_result_code(static_cast<int32_t>(RC_SUCCESS));

  auto memberData = payload->add_member_data();
  memberData->set_member_id(local);

  for (int32_t i = 0; i < stores.size(); ++ i) {
    auto& store = stores.at(i);
    auto& storeConfigWrapper = store->getStoreConfig();
    if (storeConfigWrapper->getStoreConfig().partition_type() == idgs::store::pb::PARTITION_TABLE) {
      auto pstore = dynamic_cast<idgs::store::PartitionedStore*>(store.get());

      auto& schemaName = store->getStoreConfig()->getSchema();
      auto& storeName = store->getStoreConfig()->getStoreConfig().name();
      auto storeData = memberData->add_store_data();
      storeData->set_schema_name(schemaName);
      storeData->set_store_name(storeName);

      for (int32_t p = 0; p < pcnt; ++ p) {
        auto partition = partitionMgr->getPartition(p);
        for (int32_t pos = 0; pos < bkcnt + 1; ++ pos) {
          if (partition->getMemberId(pos) == local) {
            auto partitionData = storeData->add_partition_data();
            partitionData->set_partition_id(p);
            partitionData->set_position(pos);
            partitionData->set_member_id(local);
            partitionData->set_size(pstore->dataSize(p));
            VLOG(0) << schemaName << "." << storeName << " partition " << p << "(" << pos << ") data size " << partitionData->size() << " on member " << local;

            std::shared_ptr<idgs::store::StoreMap> map;
            pstore->snapshotStore(p, map);
            auto it = map->iterator();
            while (it->hasNext()) {
              idgs::store::StoreOption ps;
              storeConfigWrapper->calculatePartitionInfo(it->key(), &ps);
              ps.memberId = partitionMgr->getPartition(ps.partitionId)->getMemberId(pos);

              auto keyPartition = partitionData->add_key_partition();
              keyPartition->set_key_partition_id(ps.partitionId);
              keyPartition->set_key_member_id(ps.memberId);

              it->next();
            }
          }
        }
      }
    }
  }

  auto respMsg = msg->createResponse();
  respMsg->setOperationName("VERIFY_RESPONSE");
  respMsg->setPayload(payload);
  idgs::actor::sendMessage(respMsg);
}
Esempio n. 26
0
	void Widget::_receive( Msg * _pMsg )
	{
		State state = m_state;

		switch( _pMsg->type() )
		{
			case MsgType::MouseEnter:
				if( m_bPressed )
					state.setPressed(true);
				else
					state.setHovered(true);
				break;
			case MsgType::MouseLeave:
				state.setHovered(false);			// Also clears any pressed flag.
				break;
			case MsgType::MousePress:
			{
				auto pMsg = static_cast<MousePressMsg*>(_pMsg);
				if( pMsg->button() == MouseButton::Left )
				{
					if( state.isHovered() )
						state.setPressed(true);

					m_bPressed = true;
				}
				break;
			}
			case MsgType::MouseRelease:
			{
				auto pMsg = static_cast<MouseReleaseMsg*>(_pMsg);
				if( pMsg->button() == MouseButton::Left )
				{
					if( state.isHovered() )
						state.setPressed(false);

					m_bPressed = false;
				}
				break;
			}
			case MsgType::FocusGained:
				state.setFocused(true);
				break;
			case MsgType::FocusLost:
				state.setFocused(false);
				break;
			case MsgType::DropPick:
			{
				auto pMsg = static_cast<DropPickMsg*>(_pMsg);
				if (!pMsg->hasPayload())
				{
					pMsg->setPayload(Payload::create());
				}
				break;
			}
			case MsgType::DropEnter:
				state.setTargeted(true);
				break;
			case MsgType::DropLeave:
				state.setTargeted(false);
				break;
			default:
				break;
		}

		if( state != m_state )
			_setState( state );
	}
void StoreMigrationSourceActor::handleMigrationRequest(const idgs::actor::ActorMessagePtr& msg) {
  // migration data
  if (it->hasNext()) {
    std::shared_ptr<pb::MigrationData> payload = std::make_shared<pb::MigrationData>();

    size_t cnt = 0;
    auto mode = static_cast<protobuf::SerdesMode>(msg->getSerdesType());
    while (it->hasNext() && cnt < batchSize) {
      auto data = payload->add_data();
      data->set_operation_name(OP_INTERNAL_INSERT);
      protobuf::ProtoSerdesHelper::serialize(mode, it->key().get(), data->mutable_key());
      protobuf::ProtoSerdesHelper::serialize(mode, it->value().get().get(), data->mutable_value());

      ++ cnt;
      it->next();
    }

    auto reqMsg = msg->createResponse();
    reqMsg->setOperationName(MIGRATION_DATA);
    reqMsg->setPayload(payload);
    idgs::actor::postMessage(reqMsg);

    return;
  }

  // migration store cache
  if (!redoLog.empty()) {
    std::shared_ptr<pb::MigrationData> payload = std::make_shared<pb::MigrationData>();

    auto mode = static_cast<protobuf::SerdesMode>(msg->getSerdesType());
    size_t cnt = 0;

    while (!redoLog.empty() && cnt < batchSize) {
      MigrationRedoLog info;
      redoLog.try_pop(info);

      if (!info.key) {
        continue;
      }

      auto data = payload->add_data();
      data->set_operation_name(info.opName);
      protobuf::ProtoSerdesHelper::serialize(mode, info.key.get(), data->mutable_key());
      if (info.value) {
        protobuf::ProtoSerdesHelper::serialize(mode, info.value.get(), data->mutable_value());
      }

      ++ cnt;
    }

    auto reqMsg = msg->createResponse();
    reqMsg->setOperationName(MIGRATION_DATA);
    reqMsg->setPayload(payload);
    idgs::actor::postMessage(reqMsg);

    return;
  }

  auto& wrapper = pstore->getStoreConfig();
  auto& schemaName = wrapper->getSchema();
  auto& storeName = wrapper->getStoreConfig().name();

  auto payload = std::make_shared<pb::StoreMigrationComplete>();
  payload->set_schema_name(schemaName);
  payload->set_store_name(storeName);
  payload->set_data_size(map->size());

  auto respMsg = msg->createResponse();
  respMsg->setOperationName(STORE_MIGRATION_COMPLETE);
  respMsg->setPayload(payload);
  DVLOG(2) << "store " << schemaName << "." << storeName << " of partition " << partId << " migration complete on source member ";
  idgs::actor::sendMessage(respMsg);

  terminate();
}
void set_datagram_pfwd_challenge(uint8_t* packet , challenge_t challenge){

	setPayload(packet,DATAGRAM_PFWD_CHALLENGE_DISP, CHALLENGE_LEN_BYTE, challenge);

}