diff --git a/libretroshare/src/gxs/rsgenexchange.cc b/libretroshare/src/gxs/rsgenexchange.cc index 287ac9964..e7edf3952 100644 --- a/libretroshare/src/gxs/rsgenexchange.cc +++ b/libretroshare/src/gxs/rsgenexchange.cc @@ -1189,6 +1189,26 @@ bool RsGenExchange::getMsgRelatedList(const uint32_t &token, MsgRelatedIdResult { return mDataAccess->getMsgRelatedList(token, msgIds); } +bool RsGenExchange::getPublishedMsgMeta(const uint32_t& token,RsMsgMetaData& meta) +{ + auto it = mPublishedMsgs.find(token); + + if(it == mPublishedMsgs.end()) + return false ; + + meta = it->second; + return true; +} +bool RsGenExchange::getPublishedGroupMeta(const uint32_t& token,RsGroupMetaData& meta) +{ + auto it = mPublishedGrps.find(token); + + if(it == mPublishedGrps.end()) + return false ; + + meta = it->second; + return true; +} bool RsGenExchange::getGroupMeta(const uint32_t &token, std::list &groupInfo) { @@ -2164,7 +2184,7 @@ void RsGenExchange::publishMsgs() #endif RsGxsMsgItem* msgItem = mit->second; - const uint32_t& token = mit->first; + uint32_t token = mit->first; uint32_t size = mSerialiser->size(msgItem); char* mData = new char[size]; @@ -2279,6 +2299,9 @@ void RsGenExchange::publishMsgs() computeHash(msg->msg, msg->metaData->mHash); mDataAccess->addMsgData(msg); + + mPublishedMsgs[token] = *msg->metaData; + delete msg ; msgChangeMap[grpId].insert(msgId); @@ -2669,6 +2692,7 @@ void RsGenExchange::publishGrps() #warning csoler: TODO: grp->meta should be renamed grp->public_meta ! grp->meta.setBinData(metaData, mdSize); } + mPublishedGrps[ggps.mToken] = *grp->metaData ; // save the connexion between the token and the created metadata, without private keys // Place back private keys for publisher and database storage grp->metaData->keys.private_keys = fullKeySet.private_keys; diff --git a/libretroshare/src/gxs/rsgenexchange.h b/libretroshare/src/gxs/rsgenexchange.h index 2144c64ae..a180c7741 100644 --- a/libretroshare/src/gxs/rsgenexchange.h +++ b/libretroshare/src/gxs/rsgenexchange.h @@ -242,6 +242,21 @@ public: */ bool getMsgRelatedMeta(const uint32_t &token, GxsMsgRelatedMetaMap& msgMeta); + /*! + * Retrieves the meta data of a newly created group. The meta is kept in cache for the current session. + * \param token token that was used to create the group + * \param meta meta data for this group + * \return false if the group is not yet created. + */ + bool getPublishedGroupMeta(const uint32_t& token,RsGroupMetaData& meta); + + /*! + * Retrieves the meta data of a newly created post. The meta is kept in cache for the current session. + * \param token token that was used to create the post + * \param meta meta data for this post + * \return false if the group is not yet created. + */ + bool getPublishedMsgMeta(const uint32_t& token,RsMsgMetaData& meta); /*! * Gxs services should call this for automatic handling of @@ -883,6 +898,9 @@ private: std::vector mGrpsToPublish; typedef std::vector NxsGrpSignPendVect; + std::map mPublishedGrps ; // keeps track of which group was created using which token + std::map mPublishedMsgs ; // keeps track of which message was created using which token + std::map mMsgsToPublish; std::map mMsgNotify; diff --git a/libretroshare/src/services/p3gxschannels.cc b/libretroshare/src/services/p3gxschannels.cc index f939ccee0..da490ee1e 100644 --- a/libretroshare/src/services/p3gxschannels.cc +++ b/libretroshare/src/services/p3gxschannels.cc @@ -1046,48 +1046,54 @@ bool p3GxsChannels::createChannel(RsGxsChannelGroup& channel) { uint32_t token; time_t beginCreation = time(nullptr); - if( !createGroup(token, channel) - || waitToken(token) != RsTokenService::COMPLETE ) + if( !createGroup(token, channel) || waitToken(token) != RsTokenService::COMPLETE ) return false; - time_t endCreation = time(nullptr); - std::list channels; - if(!getChannelsSummaries(channels)) return false; - - /* This is ugly but after digging and doing many tries of doing it the right - * way ending always into too big refactor chain reaction, I think this is - * not that bad, moreover seems the last created group tend to end up near - * the beginning of the list so it is fast founding it. - * The shortcoming of this is that if groups with same data are created in - * a burst (more then once in a second) is that the id of another similar - * group can be returned, but this is a pointy case. - * Order of conditions in the `if` matter for performances */ - bool found = false; - for(const RsGroupMetaData& chan : channels) + if(RsGenExchange::getPublishedGroupMeta(token,channel.mMeta)) { - if( IS_GROUP_ADMIN(chan.mSubscribeFlags) - && IS_GROUP_SUBSCRIBED(chan.mSubscribeFlags) - && chan.mPublishTs >= beginCreation - && chan.mPublishTs <= endCreation - && chan.mGroupFlags == channel.mMeta.mGroupFlags - && chan.mSignFlags == channel.mMeta.mSignFlags - && chan.mCircleType == channel.mMeta.mCircleType - && chan.mAuthorId == channel.mMeta.mAuthorId - && chan.mCircleId == channel.mMeta.mCircleId - && chan.mServiceString == channel.mMeta.mServiceString - && chan.mGroupName == channel.mMeta.mGroupName ) - { - channel.mMeta = chan; - found = true; - break; - } - } - #ifdef RS_DEEP_SEARCH - if(found) DeepSearch::indexChannelGroup(channel); + if(found) DeepSearch::indexChannelGroup(channel); #endif // RS_DEEP_SEARCH - return found; + return true; + } + else + return false; + +// time_t endCreation = time(nullptr); +// +// +// std::list channels; +// if(!getChannelsSummaries(channels)) return false; +// +// /* This is ugly but after digging and doing many tries of doing it the right +// * way ending always into too big refactor chain reaction, I think this is +// * not that bad, moreover seems the last created group tend to end up near +// * the beginning of the list so it is fast founding it. +// * The shortcoming of this is that if groups with same data are created in +// * a burst (more then once in a second) is that the id of another similar +// * group can be returned, but this is a pointy case. +// * Order of conditions in the `if` matter for performances */ +// bool found = false; +// for(const RsGroupMetaData& chan : channels) +// { +// if( IS_GROUP_ADMIN(chan.mSubscribeFlags) +// && IS_GROUP_SUBSCRIBED(chan.mSubscribeFlags) +// && chan.mPublishTs >= beginCreation +// && chan.mPublishTs <= endCreation +// && chan.mGroupFlags == channel.mMeta.mGroupFlags +// && chan.mSignFlags == channel.mMeta.mSignFlags +// && chan.mCircleType == channel.mMeta.mCircleType +// && chan.mAuthorId == channel.mMeta.mAuthorId +// && chan.mCircleId == channel.mMeta.mCircleId +// && chan.mServiceString == channel.mMeta.mServiceString +// && chan.mGroupName == channel.mMeta.mGroupName ) +// { +// channel.mMeta = chan; +// found = true; +// break; +// } +// } } bool p3GxsChannels::createPost(RsGxsChannelPost& post) @@ -1098,49 +1104,60 @@ bool p3GxsChannels::createPost(RsGxsChannelPost& post) || waitToken(token) != RsTokenService::COMPLETE ) return false; time_t endCreation = time(nullptr); - std::list chanIds; chanIds.push_back(post.mMeta.mGroupId); - std::vector posts; - std::vector comments; - if(!getChannelsContent(chanIds, posts, comments)) return false; - - /* This is ugly but after digging and doing many tries of doing it the right - * way ending always into too big refactor chain reaction, I think this is - * not that bad. - * The shortcoming of this is that if posts with same data are created in - * a burst (more then once in a second) is that the id of another similar - * post could be returned, but this is a pointy case. - * Order of conditions in the `if` matter for performances */ - bool found = false; - for(const RsGxsChannelPost& itPost : posts) + if(RsGenExchange::getPublishedMsgMeta(token,post.mMeta)) { - std::cout << __PRETTY_FUNCTION__ << " " << beginCreation << " " - << itPost.mMeta.mPublishTs << " " << endCreation << " " - << itPost.mMeta.mMsgId << std::endl; - - if( itPost.mMeta.mPublishTs >= beginCreation - && itPost.mMeta.mPublishTs <= endCreation - && itPost.mMeta.mMsgFlags == post.mMeta.mMsgFlags - && itPost.mMeta.mGroupId == post.mMeta.mGroupId - && itPost.mMeta.mThreadId == post.mMeta.mThreadId - && itPost.mMeta.mParentId == post.mMeta.mParentId - && itPost.mMeta.mAuthorId == post.mMeta.mAuthorId - && itPost.mMeta.mMsgName == post.mMeta.mMsgName - && itPost.mFiles.size() == post.mFiles.size() - && itPost.mMeta.mServiceString == post.mMeta.mServiceString - && itPost.mOlderVersions == post.mOlderVersions - && itPost.mMsg == post.mMsg ) - { - post = itPost; - found = true; - break; - } - } - #ifdef RS_DEEP_SEARCH - if(found) DeepSearch::indexChannelPost(post); + if(found) DeepSearch::indexChannelGroup(post); #endif // RS_DEEP_SEARCH - return found; + return true; + } + else + return false; + +// std::list chanIds; chanIds.push_back(post.mMeta.mGroupId); +// std::vector posts; +// std::vector comments; +// if(!getChannelsContent(chanIds, posts, comments)) return false; +// +// /* This is ugly but after digging and doing many tries of doing it the right +// * way ending always into too big refactor chain reaction, I think this is +// * not that bad. +// * The shortcoming of this is that if posts with same data are created in +// * a burst (more then once in a second) is that the id of another similar +// * post could be returned, but this is a pointy case. +// * Order of conditions in the `if` matter for performances */ +// bool found = false; +// for(const RsGxsChannelPost& itPost : posts) +// { +// std::cout << __PRETTY_FUNCTION__ << " " << beginCreation << " " +// << itPost.mMeta.mPublishTs << " " << endCreation << " " +// << itPost.mMeta.mMsgId << std::endl; +// +// if( itPost.mMeta.mPublishTs >= beginCreation +// && itPost.mMeta.mPublishTs <= endCreation +// && itPost.mMeta.mMsgFlags == post.mMeta.mMsgFlags +// && itPost.mMeta.mGroupId == post.mMeta.mGroupId +// && itPost.mMeta.mThreadId == post.mMeta.mThreadId +// && itPost.mMeta.mParentId == post.mMeta.mParentId +// && itPost.mMeta.mAuthorId == post.mMeta.mAuthorId +// && itPost.mMeta.mMsgName == post.mMeta.mMsgName +// && itPost.mFiles.size() == post.mFiles.size() +// && itPost.mMeta.mServiceString == post.mMeta.mServiceString +// && itPost.mOlderVersions == post.mOlderVersions +// && itPost.mMsg == post.mMsg ) +// { +// post = itPost; +// found = true; +// break; +// } +// } +// +//#ifdef RS_DEEP_SEARCH +// if(found) DeepSearch::indexChannelPost(post); +//#endif // RS_DEEP_SEARCH +// +// return found; }