/** * @inheritDoc */ void PlayerInputObject::createShot(void) { Proto::Object shotProto; shotProto.set_id(ObjectId::gen().str()); shotProto.set_name("Shot"); shotProto.set_template_("ShotTemplate"); auto physicSystemObject = shotProto.add_systemobjects(); physicSystemObject->set_systemtype(Proto::SystemType::Physic); physicSystemObject->set_type("Movable"); auto positionProperty = physicSystemObject->add_properties(); positionProperty->set_name("Position"); getVector3(&m_position, positionProperty->mutable_value()); auto orientationProperty = physicSystemObject->add_properties(); orientationProperty->set_name("Orientation"); getQuaternion(&m_orientation, orientationProperty->mutable_value()); auto networkSystemObject = shotProto.add_systemobjects(); networkSystemObject->set_systemtype(Proto::SystemType::Network); networkSystemObject->set_type("Replicable"); m_createObjectQueue->push_back(shotProto); PostChanges(System::Changes::Generic::CreateObject); }
idgs::ResultCode ActorMessage::toRpcBuffer() { idgs::ResultCode code = RC_SUCCESS; // encode payload protobuf::SerdesMode mode = (protobuf::SerdesMode) ((int32_t) getRpcMessage()->serdes_type()); if (payload.get() && (!rpcMessage->has_payload())) { if (!protobuf::ProtoSerdesHelper::serialize(mode, payload.get(), getRpcMessage()->mutable_payload())) { LOG(ERROR)<< "serialize actor message payload error! " << payload->DebugString(); code = RC_ERROR; return code; } } // encode attachments if (attachments.size() != rpcMessage->attachments_size()) { for (auto it = attachments.begin(); it != attachments.end(); ++it) { auto a = getRpcMessage()->add_attachments(); a->set_name(it->first); protobuf::ProtoSerdesHelper::serialize(mode, it->second.get(), a->mutable_value()); } } // encode whole message int32_t size = 0; size = getRpcMessage()->ByteSize(); freeRpcBuffer(); rpcBuffer = new idgs::net::RpcBuffer(); rpcBuffer->setBodyLength(size); rpcBuffer->reserveBuffer(); if (!protobuf::ProtoSerdes<DEFAULT_PB_SERDES>::serialize(rpcMessage.get(), rpcBuffer->getBody(), size)) { LOG(ERROR)<< "serialize actor message error! " << getRpcMessage()->DebugString(); code = RC_ERROR; return code; } return code; }
/// encode the message to byte array. std::string ClientActorMessage::toBuffer() { // encode payload protobuf::SerdesMode mode = (protobuf::SerdesMode) ((int32_t) rpcMessage->serdes_type()); if (payload.get()) { if (!protobuf::ProtoSerdesHelper::serialize(mode, payload.get(), rpcMessage->mutable_payload())) { LOG(ERROR)<< "parse actor message payload error! " << payload->DebugString(); return ""; } } // encode attachments for (auto it = attachments.begin(); it != attachments.end(); ++it) { auto a = rpcMessage->add_attachments(); a->set_name(it->first); protobuf::ProtoSerdesHelper::serialize(mode, it->second.get(), a->mutable_value()); // @todo remove // if (rawAttachments.find(it->first) == rawAttachments.end()) { // protobuf::ProtoSerdesHelper::serialize(mode, it->second.get(), &rawAttachments[it->first]); // } } std::string s; google::protobuf::TextFormat::PrintToString(*rpcMessage.get(), &s); DVLOG(3) << "==============to buffer=============="; DVLOG(3) << s; DVLOG(3) << "============//to buffer=============="; // encode whole message std::string result; if (!protobuf::ProtoSerdes<DEFAULT_PB_SERDES>::serialize(rpcMessage.get(), &result)) { LOG(ERROR)<< "parse actor message error! " << rpcMessage->DebugString(); return ""; } return result; }
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(); }
bool ProtoMessage::toString(std::string& result) { if (m_protoMsg == nullptr) { return false; } m_protoMsg->Clear(); for (auto itKeyMapData = m_keyMapData.begin(); itKeyMapData != m_keyMapData.end(); ++itKeyMapData) { auto& key = itKeyMapData->first; auto protoKeyMapData = m_protoMsg->add_keymapdata(); protoKeyMapData->set_key(key); auto protoMapData = protoKeyMapData->mutable_mapdata(); auto& mapData = itKeyMapData->second; for (auto itData = mapData.begin(); itData != mapData.end(); ++itData) { auto& dataKey = itData->first; const Variant& dataValue = itData->second; auto mapKeyValue = protoMapData->add_mapkeyvalue(); mapKeyValue->set_key(dataKey); auto variantValue = mapKeyValue->mutable_value(); std::string blob; dataValue.toBlob(blob); variantValue->set_data(blob); variantValue->set_type((int32_t)dataValue.type()); } } for (auto itKeyListData = m_keyListData.begin(); itKeyListData != m_keyListData.end(); ++itKeyListData) { auto& key = itKeyListData->first; auto protokeyListData = m_protoMsg->add_keylistdata(); protokeyListData->set_key(key); auto protoListData = protokeyListData->mutable_listdata(); auto& listData = itKeyListData->second; for (auto itData = listData.begin(); itData != listData.end(); ++itData) { const Variant& dataValue = *itData; auto variantValue = protoListData->add_value(); std::string blob; dataValue.toBlob(blob); variantValue->set_data(blob); variantValue->set_type((int32_t)dataValue.type()); } } for (auto itKeyTableData = m_keyTableData.begin(); itKeyTableData != m_keyTableData.end(); ++itKeyTableData) { auto& key = itKeyTableData->first; auto protoKeyTableData = m_protoMsg->add_keytabledata(); protoKeyTableData->set_key(key); auto protoTableData = protoKeyTableData->mutable_tabledata(); auto& tableData = itKeyTableData->second; int32_t lineIndex = -1; while (lineIndex++ != tableData.size() - 1) { auto list = protoTableData->add_listdata(); auto& listData = tableData[lineIndex]; int32_t dataIndex = -1; while (dataIndex++ != listData.size() - 1) { const Variant& dataValue = listData[dataIndex]; auto variantValue = list->add_value(); std::string blob; dataValue.toBlob(blob); variantValue->set_data(blob); variantValue->set_type((int32_t)dataValue.type()); } } } return m_protoMsg->SerializeToString(&result); }
bool ProtoMessage::from(const std::string& data) { if (m_protoMsg == nullptr || !m_protoMsg->ParseFromString(data)) { return false; } clearMap(); clearList(); clearTable(); int32_t index = -1; while (index++ != m_protoMsg->keymapdata_size() - 1) { auto protokeyMapData = m_protoMsg->mutable_keymapdata(index); const int32_t& key = protokeyMapData->key(); auto mapData = protokeyMapData->mutable_mapdata(); int32_t dataIndex = -1; while (dataIndex++ != mapData->mapkeyvalue_size() - 1) { auto mapKeyValue = mapData->mutable_mapkeyvalue(dataIndex); const int32_t& dataKey = mapKeyValue->key(); auto variantValue = mapKeyValue->mutable_value(); m_keyMapData[key][dataKey] = Variant(variantValue->data(), (Variant::VariantType)(variantValue->type()), true); } } index = -1; while (index++ != m_protoMsg->keylistdata_size() - 1) { auto protokeyListData = m_protoMsg->mutable_keylistdata(index); const int32_t& key = protokeyListData->key(); auto listData = protokeyListData->mutable_listdata(); int32_t dataIndex = -1; while (dataIndex++ != listData->value_size() - 1) { auto variantValue = listData->mutable_value(dataIndex); m_keyListData[key].push_back(Variant(variantValue->data(), (Variant::VariantType)(variantValue->type()), true)); } } index = -1; while (index++ != m_protoMsg->keytabledata_size() - 1) { auto protokeyTableData = m_protoMsg->mutable_keytabledata(index); const int32_t& key = protokeyTableData->key(); auto tableData = protokeyTableData->mutable_tabledata(); std::vector<std::vector<Variant>> vecData; int32_t lineIndex = -1; while (lineIndex++ != tableData->listdata_size() - 1) { std::vector<Variant> vecLine; auto list = tableData->mutable_listdata(lineIndex); int32_t dataIndex = -1; while (dataIndex++ != list->value_size() - 1) { auto variantValue = list->mutable_value(dataIndex); vecLine.push_back(Variant(variantValue->data(), (Variant::VariantType)(variantValue->type()), true)); } vecData.push_back(vecLine); } m_keyTableData[key] = vecData; } return true; }