Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-06-05 13:19:32 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Nxs items now do not support the concept of version

Browse source 
timestamp has been added to grp sync item 
updated data service and grps to deal with this
added msg and grp meta types which serves to hold meta data of grp and msg 
removed observer temporarily 

updated nxs item tests, need to update data service tests

git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.5-new_cache_system@5256 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
chrisparker126 2012-06-26 19:52:01 +00:00
parent 03e2ee72e0
commit d533a2e580
15 changed files with 965 additions and 729 deletions
Download patch file Download diff file Expand all files Collapse all files

608
libretroshare/src/gxs/rsdataservice.cc
View file

@ -15,38 +15,76 @@
#define KEY_IDENTITY_SIGN std::string("idSign") #define KEY_IDENTITY_SIGN std::string("idSign")
#define KEY_TIME_STAMP std::string("timeStamp") #define KEY_TIME_STAMP std::string("timeStamp")
#define KEY_NXS_FLAGS std::string("flags") #define KEY_NXS_FLAGS std::string("flags")
#define KEY_NXS_META std::string("meta")
// grp table columns // grp table columns
#define KEY_ADMIN_SIGN std::string("adminSign") #define KEY_ADMIN_SIGN std::string("adminSign")
#define KEY_KEY_SET std::string("keySet") #define KEY_KEY_SET std::string("keySet")
#define KEY_GRP_NAME std::string("grpName")
// grp local
#define KEY_GRP_SUBCR_FLAG std::string("subscribeFlag")
#define KEY_GRP_POP std::string("popularity")
#define KEY_MSG_COUNT std::string("msgCount")
#define KEY_GRP_STATUS std::string("grpStatus")
#define KEY_GRP_LAST_POST std::string("lastPost")
// msg table columns // msg table columns
#define KEY_PUBLISH_SIGN std::string("publishSign") #define KEY_PUBLISH_SIGN std::string("publishSign")
#define KEY_MSG_ID std::string("msgId") #define KEY_MSG_ID std::string("msgId")
#define KEY_ORIG_MSG_ID std::string("origMsgId") #define KEY_ORIG_MSG_ID std::string("origMsgId")
#define KEY_MSG_PARENT_ID std::string("parentId")
#define KEY_MSG_THREAD_ID std::string("threadId")
#define KEY_MSG_NAME std::string("msgName")
// msg local
#define KEY_MSG_STATUS std::string("msgStatus")
#define KEY_CHILD_TS std::string("childTs")
/*** actual data col numbers ***/
// generic
#define COL_ACT_GROUP_ID 0
#define COL_NXS_FILE 1
#define COL_NXS_FILE_OFFSET 2
#define COL_NXS_FILE_LEN 3
#define COL_META_DATA 4
#define COL_ACT_MSG_ID 5
/*** meta column numbers ***/
// grp col numbers // grp col numbers
#define COL_GRP_ID 0
#define COL_ADMIN_SIGN 1 #define COL_ADMIN_SIGN 5
#define COL_KEY_SET 9 #define COL_KEY_SET 6
#define COL_GRP_SUBCR_FLAG 7
#define COL_GRP_POP 8
#define COL_MSG_COUNT 9
#define COL_GRP_STATUS 11
#define COL_GRP_NAME 12
#define COL_GRP_LAST_POST 13
// msg col numbers // msg col numbers
#define COL_PUBLISH_SIGN 1 #define COL_PUBLISH_SIGN 5
#define COL_MSG_ID 9 #define COL_MSG_ID 6
#define COL_ORIG_MSG_ID 10 #define COL_ORIG_MSG_ID 7
#define COL_MSG_STATUS 8
// generic col numbers #define COL_CHILD_TS 9
#define COL_NXS_FILE 2 #define COL_PARENT_ID 10
#define COL_NXS_FILE_OFFSET 3 #define COL_THREAD_ID 11
#define COL_NXS_FILE_LEN 4 #define COL_MSG_NAME 12
#define COL_TIME_STAMP 5
#define COL_NXS_FLAGS 6
#define COL_IDENTITY_SIGN 7
#define COL_IDENTITY 8
// generic meta shared col numbers
#define COL_GRP_ID 0
#define COL_TIME_STAMP 1
#define COL_NXS_FLAGS 2
#define COL_IDENTITY_SIGN 3
#define COL_IDENTITY 4
#define RS_DATA_SERVICE_DEBUG #define RS_DATA_SERVICE_DEBUG
@ -56,15 +94,27 @@ RsDataService::RsDataService(const std::string &serviceDir, const std::string &d
initialise(); initialise();
msgColumns.push_back(KEY_GRP_ID); msgColumns.push_back(KEY_PUBLISH_SIGN); msgColumns.push_back(KEY_NXS_FILE); // for retrieving msg meta
msgColumns.push_back(KEY_NXS_FILE_OFFSET); msgColumns.push_back(KEY_NXS_FILE_LEN); msgColumns.push_back(KEY_TIME_STAMP); msgMetaColumns.push_back(KEY_GRP_ID); msgMetaColumns.push_back(KEY_TIME_STAMP); msgMetaColumns.push_back(KEY_NXS_FLAGS);
msgColumns.push_back(KEY_NXS_FLAGS); msgColumns.push_back(KEY_IDENTITY_SIGN); msgColumns.push_back(KEY_NXS_IDENTITY); msgMetaColumns.push_back(KEY_IDENTITY_SIGN); msgMetaColumns.push_back(KEY_NXS_IDENTITY); msgMetaColumns.push_back(KEY_PUBLISH_SIGN);
msgColumns.push_back(KEY_MSG_ID); msgColumns.push_back(KEY_ORIG_MSG_ID); msgMetaColumns.push_back(KEY_MSG_ID); msgMetaColumns.push_back(KEY_ORIG_MSG_ID); msgMetaColumns.push_back(KEY_MSG_STATUS);
msgMetaColumns.push_back(KEY_CHILD_TS); msgMetaColumns.push_back(KEY_MSG_PARENT_ID); msgMetaColumns.push_back(KEY_MSG_THREAD_ID);
msgMetaColumns.push_back(KEY_MSG_NAME);
grpColumns.push_back(KEY_GRP_ID); grpColumns.push_back(KEY_ADMIN_SIGN); grpColumns.push_back(KEY_NXS_FILE); // for retrieving actual data
grpColumns.push_back(KEY_NXS_FILE_OFFSET); grpColumns.push_back(KEY_NXS_FILE_LEN); grpColumns.push_back(KEY_TIME_STAMP); msgColumns.push_back(KEY_GRP_ID); msgColumns.push_back(KEY_NXS_FILE); msgColumns.push_back(KEY_NXS_FILE_OFFSET);
grpColumns.push_back(KEY_NXS_FLAGS); grpColumns.push_back(KEY_IDENTITY_SIGN); msgColumns.push_back(KEY_NXS_FILE_LEN); msgColumns.push_back(KEY_NXS_META); msgColumns.push_back(KEY_MSG_ID);
grpColumns.push_back(KEY_NXS_IDENTITY); grpColumns.push_back(KEY_KEY_SET);
// for retrieving grp meta data
grpMetaColumns.push_back(KEY_GRP_ID); grpMetaColumns.push_back(KEY_TIME_STAMP); grpMetaColumns.push_back(KEY_NXS_FLAGS);
grpMetaColumns.push_back(KEY_IDENTITY_SIGN); grpMetaColumns.push_back(KEY_NXS_IDENTITY); grpMetaColumns.push_back(KEY_ADMIN_SIGN);
grpMetaColumns.push_back(KEY_KEY_SET); grpMetaColumns.push_back(KEY_GRP_SUBCR_FLAG); grpMetaColumns.push_back(KEY_GRP_POP);
grpMetaColumns.push_back(KEY_MSG_COUNT); grpMetaColumns.push_back(KEY_GRP_STATUS); grpMetaColumns.push_back(KEY_GRP_NAME);
grpMetaColumns.push_back(KEY_GRP_LAST_POST);
// for retrieving actual grp data
grpColumns.push_back(KEY_GRP_ID); grpColumns.push_back(KEY_NXS_FILE); grpColumns.push_back(KEY_NXS_FILE_OFFSET);
grpColumns.push_back(KEY_NXS_FILE_LEN); grpColumns.push_back(KEY_NXS_META);
} }
RsDataService::~RsDataService(){ RsDataService::~RsDataService(){
@ -77,23 +127,89 @@ void RsDataService::initialise(){
// initialise database // initialise database
mDb = new RetroDb(mDbName, RetroDb::OPEN_READWRITE_CREATE); mDb = new RetroDb(mDbName, RetroDb::OPEN_READWRITE_CREATE);
// create table for msgs // create table for msg data
mDb->execSQL("CREATE TABLE " + MSG_TABLE_NAME + "(" + KEY_MSG_ID mDb->execSQL("CREATE TABLE " + MSG_TABLE_NAME + "(" + KEY_MSG_ID
+ " TEXT," + KEY_GRP_ID + " TEXT," + KEY_NXS_FLAGS + " INT," + KEY_ORIG_MSG_ID + " TEXT," + " TEXT," + KEY_GRP_ID + " TEXT," + KEY_NXS_FLAGS + " INT," + KEY_ORIG_MSG_ID + " TEXT,"
+ KEY_TIME_STAMP + " INT," + KEY_PUBLISH_SIGN + " BLOB," + KEY_NXS_IDENTITY + " TEXT," + KEY_TIME_STAMP + " INT," + KEY_PUBLISH_SIGN + " BLOB," + KEY_NXS_IDENTITY + " TEXT,"
+ KEY_IDENTITY_SIGN + " BLOB," + KEY_NXS_FILE + " TEXT,"+ KEY_NXS_FILE_OFFSET + " INT," + KEY_IDENTITY_SIGN + " BLOB," + KEY_NXS_FILE + " TEXT,"+ KEY_NXS_FILE_OFFSET + " INT,"
+ KEY_MSG_STATUS + " INT," + KEY_CHILD_TS + " INT,"+ KEY_NXS_META + " BLOB,"
+ KEY_MSG_THREAD_ID + " TEXT," + KEY_MSG_PARENT_ID + " TEXT,"+ KEY_MSG_NAME + " TEXT,"
+ KEY_NXS_FILE_LEN+ " INT);"); + KEY_NXS_FILE_LEN+ " INT);");
// create table for grps // create table for grp data
mDb->execSQL("CREATE TABLE " + GRP_TABLE_NAME + "(" + KEY_GRP_ID + mDb->execSQL("CREATE TABLE " + GRP_TABLE_NAME + "(" + KEY_GRP_ID +
" TEXT," + KEY_TIME_STAMP + " INT," + " TEXT," + KEY_TIME_STAMP + " INT," +
KEY_ADMIN_SIGN + " BLOB," + " BLOB," + KEY_NXS_FILE + KEY_ADMIN_SIGN + " BLOB," + " BLOB," + KEY_NXS_FILE +
" TEXT," + KEY_NXS_FILE_OFFSET + " INT," + KEY_KEY_SET + " BLOB," + KEY_NXS_FILE_LEN + " INT," " TEXT," + KEY_NXS_FILE_OFFSET + " INT," + KEY_KEY_SET + " BLOB," + KEY_NXS_FILE_LEN + " INT,"
+ KEY_NXS_META + " BLOB," + KEY_GRP_NAME + " TEXT," + KEY_GRP_LAST_POST + " INT,"
+ KEY_GRP_LAST_POST + " INT," + KEY_GRP_POP + " INT," + KEY_MSG_COUNT + " INT,"
+ KEY_GRP_SUBCR_FLAG + " INT," + KEY_GRP_STATUS + " INT,"
+ KEY_NXS_IDENTITY + " TEXT," + KEY_NXS_FLAGS + " INT," + KEY_IDENTITY_SIGN + " BLOB);"); + KEY_NXS_IDENTITY + " TEXT," + KEY_NXS_FLAGS + " INT," + KEY_IDENTITY_SIGN + " BLOB);");
} }
RsNxsGrp* RsDataService::getGroup(RetroCursor &c){ RsGxsGrpMetaData* RsDataService::getGrpMeta(RetroCursor &c)
{
RsGxsGrpMetaData* grpMeta = new RsGxsGrpMetaData();
bool ok = true;
// for manipulating raw data
uint32_t offset = 0;
char* data = NULL;
uint32_t data_len = 0;
// grpId
c.getString(COL_GRP_ID, grpMeta->mGroupId);
// required definition of a group
ok &= !grpMeta->mGroupId.empty();
// identity if any
c.getString(COL_IDENTITY, grpMeta->mAuthorId);
c.getString(COL_GRP_NAME, grpMeta->mGroupName);
grpMeta->mPublishTs = c.getInt32(COL_TIME_STAMP);
grpMeta->mGroupFlags = c.getInt32(COL_NXS_FLAGS);
if(!grpMeta->mAuthorId.empty() && ok){
offset = 0;
data = (char*)c.getData(COL_IDENTITY_SIGN, data_len);
if(data)
grpMeta->idSign.GetTlv(data, data_len, &offset);
}
offset = 0;
data = (char*)c.getData(COL_ADMIN_SIGN, data_len);
if(data)
grpMeta->adminSign.GetTlv(data, data_len, &offset);
offset = 0; data = NULL; data_len = 0;
data = (char*)c.getData(COL_KEY_SET, data_len);
if(data)
ok &= grpMeta->keys.GetTlv(data, data_len, &offset);
// local meta
grpMeta->mSubscribeFlags = c.getInt32(COL_GRP_SUBCR_FLAG);
grpMeta->mPop = c.getInt32(COL_GRP_POP);
grpMeta->mMsgCount = c.getInt32(COL_MSG_COUNT);
grpMeta->mLastPost = c.getInt32(COL_GRP_LAST_POST);
grpMeta->mGroupStatus = c.getInt32(COL_GRP_STATUS);
if(ok)
return grpMeta;
else
delete grpMeta;
return NULL;
}
RsNxsGrp* RsDataService::getGroup(RetroCursor &c)
{
/*! /*!
* grpId, pub admin and pub publish key * grpId, pub admin and pub publish key
@ -109,43 +225,21 @@ RsNxsGrp* RsDataService::getGroup(RetroCursor &c){
uint32_t data_len = 0; uint32_t data_len = 0;
// grpId // grpId
c.getString(COL_GRP_ID, grp->grpId); c.getString(COL_ACT_GROUP_ID, grp->grpId);
ok &= !grp->grpId.empty(); ok &= !grp->grpId.empty();
// identity if any offset = 0; data_len = 0;
c.getString(COL_IDENTITY, grp->identity); if(ok){
grp->timeStamp = c.getInt32(COL_TIME_STAMP);
if(!( grp->identity.empty() ) && ok){ data = (char*)c.getData(COL_META_DATA, data_len);
offset = 0; if(data)
data = (char*)c.getData(COL_IDENTITY_SIGN, data_len); grp->meta.GetTlv(data, data_len, &offset);
if(data){
grp->idSign.GetTlv(data, data_len, &offset);
}
}
offset = 0;
data = (char*)c.getData(COL_ADMIN_SIGN, data_len);
if(data){
grp->adminSign.GetTlv(data, data_len, &offset);
}
grp->grpFlag = c.getInt32(COL_NXS_FLAGS);
offset = 0; data = NULL; data_len = 0;
data = (char*)c.getData(COL_KEY_SET, data_len);
if(data){
ok &= grp->keys.GetTlv(data, data_len, &offset);
} }
/* now retrieve grp data from file */
std::string grpFile; std::string grpFile;
c.getString(COL_NXS_FILE, grpFile); c.getString(COL_NXS_FILE, grpFile);
ok &= !grpFile.empty(); ok &= !grpFile.empty();
/* now retrieve grp data from file */
if(ok){ if(ok){
@ -170,8 +264,65 @@ RsNxsGrp* RsDataService::getGroup(RetroCursor &c){
return NULL; return NULL;
} }
RsGxsMsgMetaData* RsDataService::getMsgMeta(RetroCursor &c)
{
RsNxsMsg* RsDataService::getMessage(RetroCursor &c){ RsGxsMsgMetaData* msgMeta = new RsGxsMsgMetaData();
bool ok = true;
uint32_t data_len = 0,
offset = 0;
char* data = NULL;
c.getString(COL_GRP_ID, msgMeta->mGroupId);
c.getString(COL_MSG_ID, msgMeta->mMsgId);
// without these, a msg is meaningless
ok &= (!msgMeta->mGroupId.empty()) && (!msgMeta->mMsgId.empty());
c.getString(COL_ORIG_MSG_ID, msgMeta->mOrigMsgId);
c.getString(COL_IDENTITY, msgMeta->mAuthorId);
c.getString(COL_MSG_NAME, msgMeta->mMsgName);
if(!msgMeta->mAuthorId.empty()){
offset = 0;
data = (char*)c.getData(COL_IDENTITY_SIGN, data_len);
msgMeta->idSign.GetTlv(data, data_len, &offset);
}
msgMeta->mMsgFlags = c.getInt32(COL_NXS_FLAGS);
msgMeta->mPublishTs = c.getInt32(COL_TIME_STAMP);
offset = 0; data_len = 0;
if(ok){
data = (char*)c.getData(COL_PUBLISH_SIGN, data_len);
if(data)
msgMeta->pubSign.GetTlv(data, data_len, &offset);
}
// thread and parent id
c.getString(COL_THREAD_ID, msgMeta->mThreadId);
c.getString(COL_PARENT_ID, msgMeta->mParentId);
// local meta
msgMeta->mMsgStatus = c.getInt32(COL_MSG_STATUS);
msgMeta->mChildTs = c.getInt32(COL_CHILD_TS);
if(ok)
return msgMeta;
else
delete msgMeta;
return NULL;
}
RsNxsMsg* RsDataService::getMessage(RetroCursor &c)
{
RsNxsMsg* msg = new RsNxsMsg(mServType); RsNxsMsg* msg = new RsNxsMsg(mServType);
@ -179,37 +330,25 @@ RsNxsMsg* RsDataService::getMessage(RetroCursor &c){
uint32_t data_len = 0, uint32_t data_len = 0,
offset = 0; offset = 0;
char* data = NULL; char* data = NULL;
c.getString(COL_GRP_ID, msg->grpId); c.getString(COL_ACT_GROUP_ID, msg->grpId);
c.getString(COL_MSG_ID, msg->msgId); c.getString(COL_ACT_MSG_ID, msg->msgId);
ok &= (!msg->grpId.empty()) && (!msg->msgId.empty()); ok &= (!msg->grpId.empty()) && (!msg->msgId.empty());
c.getString(COL_IDENTITY, msg->identity);
if(!msg->identity.empty()){
offset = 0;
data = (char*)c.getData(COL_IDENTITY_SIGN, data_len);
msg->idSign.GetTlv(data, data_len, &offset);
}
msg->msgFlag = c.getInt32(COL_NXS_FLAGS);
msg->timeStamp = c.getInt32(COL_TIME_STAMP);
offset = 0; data_len = 0; offset = 0; data_len = 0;
if(ok){ if(ok){
data = (char*)c.getData(COL_PUBLISH_SIGN, data_len); data = (char*)c.getData(COL_META_DATA, data_len);
if(data) if(data)
msg->publishSign.GetTlv(data, data_len, &offset); msg->meta.GetTlv(data, data_len, &offset);
} }
/* now retrieve grp data from file */
std::string msgFile; std::string msgFile;
c.getString(COL_NXS_FILE, msgFile); c.getString(COL_NXS_FILE, msgFile);
offset = c.getInt32(COL_NXS_FILE_OFFSET); offset = c.getInt32(COL_NXS_FILE_OFFSET);
data_len = c.getInt32(COL_NXS_FILE_LEN); data_len = c.getInt32(COL_NXS_FILE_LEN);
ok &= !msgFile.empty(); ok &= !msgFile.empty();
/* now retrieve grp data from file */
if(ok){ if(ok){
@ -231,44 +370,60 @@ RsNxsMsg* RsDataService::getMessage(RetroCursor &c){
return NULL; return NULL;
} }
int RsDataService::storeMessage(std::set<RsNxsMsg *> &msg){ int RsDataService::storeMessage(std::map<RsNxsMsg *, RsGxsMsgMetaData *> &msg)
{
std::map<RsNxsMsg*, RsGxsMsgMetaData* >::iterator mit = msg.begin();
std::set<RsNxsMsg*>::iterator sit = msg.begin();
// start a transaction
mDb->execSQL("BEGIN;"); mDb->execSQL("BEGIN;");
for(; mit != msg.end(); mit++){
for(; sit != msg.end(); sit++){ RsNxsMsg* msgPtr = mit->first;
RsGxsMsgMetaData* msgMetaPtr = mit->second;
RsNxsMsg* msgPtr = *sit; // create or access file in binary
std::string msgFile = mServiceDir + "/" + msgPtr->grpId + "-msgs"; std::string msgFile = mServiceDir + "/" + msgPtr->grpId + "-msgs";
std::fstream ostrm(msgFile.c_str(), std::ios::binary | std::ios::app | std::ios::out); std::fstream ostrm(msgFile.c_str(), std::ios::binary | std::ios::app | std::ios::out);
ostrm.seekg(0, std::ios::end); // go to end to append ostrm.seekg(0, std::ios::end); // go to end to append
uint32_t offset = ostrm.tellg(); // get fill offset uint32_t offset = ostrm.tellg(); // get fill offset
ContentValue cv; ContentValue cv;
cv.put(KEY_NXS_FILE_OFFSET, (int32_t)offset); cv.put(KEY_NXS_FILE_OFFSET, (int32_t)offset);
cv.put(KEY_NXS_FILE, msgFile); cv.put(KEY_NXS_FILE, msgFile);
cv.put(KEY_NXS_FILE_LEN, (int32_t)msgPtr->msg.TlvSize()); cv.put(KEY_NXS_FILE_LEN, (int32_t)msgPtr->msg.TlvSize());
cv.put(KEY_MSG_ID, msgPtr->msgId); cv.put(KEY_MSG_ID, msgMetaPtr->mMsgId);
cv.put(KEY_GRP_ID, msgPtr->grpId); cv.put(KEY_GRP_ID, msgMetaPtr->mGroupId);
char pubSignData[msgPtr->publishSign.TlvSize()]; char pubSignData[msgMetaPtr->pubSign.TlvSize()];
offset = 0; offset = 0;
msgPtr->publishSign.SetTlv(pubSignData, msgPtr->publishSign.TlvSize(), &offset); msgMetaPtr->pubSign.SetTlv(pubSignData, msgMetaPtr->pubSign.TlvSize(), &offset);
cv.put(KEY_PUBLISH_SIGN, msgPtr->publishSign.TlvSize(), pubSignData); cv.put(KEY_PUBLISH_SIGN, msgMetaPtr->pubSign.TlvSize(), pubSignData);
if(! (msgPtr->identity.empty()) ){ if(! (msgMetaPtr->mAuthorId.empty()) ){
char idSignData[msgPtr->idSign.TlvSize()]; char idSignData[msgMetaPtr->idSign.TlvSize()];
offset = 0; offset = 0;
msgPtr->idSign.SetTlv(idSignData, msgPtr->idSign.TlvSize(), &offset); msgMetaPtr->idSign.SetTlv(idSignData, msgMetaPtr->idSign.TlvSize(), &offset);
cv.put(KEY_IDENTITY_SIGN, msgPtr->idSign.TlvSize(), idSignData); cv.put(KEY_IDENTITY_SIGN, msgMetaPtr->idSign.TlvSize(), idSignData);
cv.put(KEY_NXS_IDENTITY, msgPtr->identity); cv.put(KEY_NXS_IDENTITY, msgMetaPtr->mAuthorId);
} }
cv.put(KEY_NXS_FLAGS, (int32_t) msgPtr->msgFlag); cv.put(KEY_NXS_FLAGS, (int32_t) msgMetaPtr->mMsgFlags);
cv.put(KEY_TIME_STAMP, (int32_t) msgPtr->timeStamp); cv.put(KEY_TIME_STAMP, (int32_t) msgMetaPtr->mPublishTs);
offset = 0;
char metaData[msgPtr->meta.TlvSize()];
msgPtr->meta.SetTlv(metaData, msgPtr->meta.TlvSize(), &offset);
cv.put(KEY_NXS_META, msgPtr->meta.TlvSize(), metaData);
cv.put(KEY_MSG_PARENT_ID, msgMetaPtr->mParentId);
cv.put(KEY_MSG_THREAD_ID, msgMetaPtr->mThreadId);
cv.put(KEY_MSG_NAME, msgMetaPtr->mMsgName);
// now local meta
cv.put(KEY_MSG_STATUS, (int32_t)msgMetaPtr->mMsgStatus);
cv.put(KEY_CHILD_TS, (int32_t)msgMetaPtr->mChildTs);
offset = 0; offset = 0;
char msgData[msgPtr->msg.TlvSize()]; char msgData[msgPtr->msg.TlvSize()];
@ -276,58 +431,77 @@ int RsDataService::storeMessage(std::set<RsNxsMsg *> &msg){
ostrm.write(msgData, msgPtr->msg.TlvSize()); ostrm.write(msgData, msgPtr->msg.TlvSize());
ostrm.close(); ostrm.close();
mDb->sqlInsert(MSG_TABLE_NAME, "", cv); mDb->sqlInsert(MSG_TABLE_NAME, "", cv);
} }
// finish transaction
return mDb->execSQL("COMMIT;");; return mDb->execSQL("COMMIT;");;
} }
int RsDataService::storeGroup(std::set<RsNxsGrp *> &grp){ int RsDataService::storeGroup(std::map<RsNxsGrp *, RsGxsGrpMetaData *> &grp)
{
std::map<RsNxsGrp*, RsGxsGrpMetaData* >::iterator sit = grp.begin();
std::set<RsNxsGrp*>::iterator sit = grp.begin();
// begin transaction
mDb->execSQL("BEGIN;"); mDb->execSQL("BEGIN;");
for(; sit != grp.end(); sit++){ for(; sit != grp.end(); sit++){
RsNxsGrp* grpPtr = *sit; RsNxsGrp* grpPtr = sit->first;
RsGxsGrpMetaData* grpMetaPtr = sit->second;
std::string grpFile = mServiceDir + "/" + grpPtr->grpId; std::string grpFile = mServiceDir + "/" + grpPtr->grpId;
std::fstream ostrm(grpFile.c_str(), std::ios::binary | std::ios::app | std::ios::out); std::fstream ostrm(grpFile.c_str(), std::ios::binary | std::ios::app | std::ios::out);
ostrm.seekg(0, std::ios::end); // go to end to append ostrm.seekg(0, std::ios::end); // go to end to append
uint32_t offset = ostrm.tellg(); // get fill offset uint32_t offset = ostrm.tellg(); // get fill offset
/*!
* STORE file offset, file length, file name,
* grpId, flags, publish time stamp, identity,
* id signature, admin signatue, key set, last posting ts
* and meta data
**/
ContentValue cv; ContentValue cv;
cv.put(KEY_NXS_FILE_OFFSET, (int32_t)offset); cv.put(KEY_NXS_FILE_OFFSET, (int32_t)offset);
cv.put(KEY_NXS_FILE_LEN, (int32_t)grpPtr->grp.TlvSize()); cv.put(KEY_NXS_FILE_LEN, (int32_t)grpPtr->grp.TlvSize());
cv.put(KEY_NXS_FILE, grpFile); cv.put(KEY_NXS_FILE, grpFile);
cv.put(KEY_GRP_ID, grpPtr->grpId); cv.put(KEY_GRP_ID, grpMetaPtr->mGroupId);
cv.put(KEY_NXS_FLAGS, (int32_t)grpPtr->grpFlag); cv.put(KEY_NXS_FLAGS, (int32_t)grpMetaPtr->mGroupFlags);
cv.put(KEY_TIME_STAMP, (int32_t)grpPtr->timeStamp); cv.put(KEY_TIME_STAMP, (int32_t)grpMetaPtr->mPublishTs);
if(! (grpPtr->identity.empty()) ){ if(! (grpMetaPtr->mAuthorId.empty()) ){
cv.put(KEY_NXS_IDENTITY, grpPtr->identity); cv.put(KEY_NXS_IDENTITY, grpMetaPtr->mAuthorId);
char idSignData[grpPtr->idSign.TlvSize()]; char idSignData[grpMetaPtr->idSign.TlvSize()];
offset = 0; offset = 0;
grpPtr->idSign.SetTlv(idSignData, grpPtr->idSign.TlvSize(), &offset); grpMetaPtr->idSign.SetTlv(idSignData, grpMetaPtr->idSign.TlvSize(), &offset);
cv.put(KEY_IDENTITY_SIGN, grpPtr->idSign.TlvSize(), idSignData); cv.put(KEY_IDENTITY_SIGN, grpMetaPtr->idSign.TlvSize(), idSignData);
std::string wat(idSignData, grpPtr->idSign.TlvSize()); std::string wat(idSignData, grpMetaPtr->idSign.TlvSize());
std::cerr << wat << std::endl; std::cerr << wat << std::endl;
} }
char adminSignData[grpPtr->adminSign.TlvSize()]; char adminSignData[grpMetaPtr->adminSign.TlvSize()];
offset = 0; offset = 0;
grpPtr->adminSign.SetTlv(adminSignData, grpPtr->adminSign.TlvSize(), &offset); grpMetaPtr->adminSign.SetTlv(adminSignData, grpMetaPtr->adminSign.TlvSize(), &offset);
cv.put(KEY_ADMIN_SIGN, grpPtr->adminSign.TlvSize(), adminSignData); cv.put(KEY_ADMIN_SIGN, grpMetaPtr->adminSign.TlvSize(), adminSignData);
offset = 0; offset = 0;
char keySetData[grpPtr->keys.TlvSize()]; char keySetData[grpMetaPtr->keys.TlvSize()];
grpPtr->keys.SetTlv(keySetData, grpPtr->keys.TlvSize(), &offset); grpMetaPtr->keys.SetTlv(keySetData, grpMetaPtr->keys.TlvSize(), &offset);
cv.put(KEY_KEY_SET, grpPtr->keys.TlvSize(), keySetData); cv.put(KEY_KEY_SET, grpMetaPtr->keys.TlvSize(), keySetData);
offset = 0;
char metaData[grpPtr->meta.TlvSize()];
grpPtr->meta.SetTlv(metaData, grpPtr->meta.TlvSize(), &offset);
cv.put(KEY_NXS_META, grpPtr->meta.TlvSize(), metaData);
// local meta data
cv.put(KEY_GRP_SUBCR_FLAG, (int32_t)grpMetaPtr->mSubscribeFlags);
cv.put(KEY_GRP_POP, (int32_t)grpMetaPtr->mPop);
cv.put(KEY_MSG_COUNT, (int32_t)grpMetaPtr->mMsgCount);
cv.put(KEY_GRP_STATUS, (int32_t)grpMetaPtr->mGroupStatus);
cv.put(KEY_GRP_LAST_POST, (int32_t)grpMetaPtr->mLastPost);
offset = 0; offset = 0;
char grpData[grpPtr->grp.TlvSize()]; char grpData[grpPtr->grp.TlvSize()];
@ -337,11 +511,11 @@ int RsDataService::storeGroup(std::set<RsNxsGrp *> &grp){
mDb->sqlInsert(GRP_TABLE_NAME, "", cv); mDb->sqlInsert(GRP_TABLE_NAME, "", cv);
} }
// finish transaction
return mDb->execSQL("COMMIT;"); return mDb->execSQL("COMMIT;");
} }
int RsDataService::retrieveGrps(std::map<std::string, RsNxsGrp*> &grp, bool cache){ int RsDataService::retrieveNxsGrps(std::map<std::string, RsNxsGrp *> &grp, bool cache){
RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, grpColumns, "", ""); RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, grpColumns, "", "");
@ -353,19 +527,9 @@ int RsDataService::retrieveGrps(std::map<std::string, RsNxsGrp*> &grp, bool cach
RsNxsGrp* g = getGroup(*c); RsNxsGrp* g = getGroup(*c);
// only add the latest grp info // only add the latest grp info
if(g){ if(g)
bool exists = grp.find(g->grpId) != grp.end(); {
if(exists){ grp[g->grpId] = g;
if(grp[g->grpId]->timeStamp < g->timeStamp){
delete grp[g->grpId];
grp[g->grpId] = g;
}else{
delete g;
}
}else{
grp[g->grpId] = g;
}
} }
valid = c->moveToNext(); valid = c->moveToNext();
} }
@ -377,111 +541,128 @@ int RsDataService::retrieveGrps(std::map<std::string, RsNxsGrp*> &grp, bool cach
} }
} }
int RsDataService::retrieveMsgs(const std::string &grpId, std::map<std::string, RsNxsMsg *>& msg, bool cache){ int RsDataService::retrieveNxsMsgs(const GxsMsgReq &reqIds, GxsMsgResult &msg, bool cache)
{
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgColumns, KEY_GRP_ID+ "='" + grpId + "'", ""); GxsMsgReq::const_iterator mit = reqIds.begin();
if(c){ for(; mit != reqIds.end(); mit++)
{
bool valid = c->moveToFirst(); const std::string& grpId = mit->first;
while(valid){
RsNxsMsg* m = getMessage(*c);
if(m){ // if vector empty then request all messages
// only add the latest grp info const std::set<std::string>& msgIdSet = mit->second;
bool exists = msg.find(m->msgId) != msg.end(); std::vector<RsNxsMsg*> msgSet;
if(exists){
if(msg[m->msgId]->timeStamp < m->timeStamp){ if(msgIdSet.empty()){
delete msg[m->msgId]; RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgColumns, KEY_GRP_ID+ "='" + grpId + "'", "");
msg[m->msgId] = m;
}else{
delete m;
}
}else{
msg[m->msgId] = m;
}
if(c)
retrieveMessages(c, msgSet);
}else{
// request each grp
std::set<std::string>::const_iterator sit = msgIdSet.begin();
for(; sit!=msgIdSet.end();sit++){
const std::string& msgId = *sit;
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgColumns, KEY_GRP_ID+ "='" + grpId + "','" + msgId + "'", "");
retrieveMessages(c, msgSet);
} }
valid = c->moveToNext();
} }
delete c; msg[grpId] = msgSet;
return 1;
}else{
return 0;
} }
} }
int RsDataService::retrieveGrpVersions(const std::string &grpId, std::set<RsNxsGrp *> &grp, bool cache){ void RsDataService::retrieveMessages(RetroCursor *c, std::vector<RsNxsMsg *> &msgs)
{
bool valid = c->moveToFirst();
while(valid){
RsNxsMsg* m = getMessage(*c);
std::string selection = KEY_GRP_ID + "='" + grpId + "'"; if(m){
RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, grpColumns, selection, ""); msgs.push_back(m);;
}else{
delete m;
}
if(c){ valid = c->moveToNext();
}
return;
}
int RsDataService::retrieveGxsMsgMetaData(const std::vector<std::string> &grpIds, GxsMsgMetaResult &msgMeta)
{
std::vector<std::string>::const_iterator vit = grpIds.begin();
for(; vit != grpIds.end(); vit++)
{
const std::string& grpId = *vit;
std::vector<RsGxsMsgMetaData*> meta;
RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgMetaColumns, "", KEY_GRP_ID+ "='" + grpId + "'");
if(c)
{
bool valid = c->moveToFirst();
while(valid){
RsGxsMsgMetaData* m = getMsgMeta(*c);
if(m){
meta.push_back(m);
}else{
delete m;
}
valid = c->moveToNext();
}
msgMeta[grpId] = meta;
}
}
return 1;
}
int RsDataService::retrieveGxsGrpMetaData(std::map<std::string, RsGxsGrpMetaData *>& grp)
{
RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, grpMetaColumns, "", "");
if(c)
{
bool valid = c->moveToFirst(); bool valid = c->moveToFirst();
while(valid){
RsNxsGrp* g = getGroup(*c); while(valid)
{
RsGxsGrpMetaData* g = getGrpMeta(*c);
if(g) if(g)
grp.insert(g); {
grp[g->mGroupId] = g;
}
valid = c->moveToNext(); valid = c->moveToNext();
} }
delete c;
return 1;
}else{
return 0;
}
}
RsNxsGrp* RsDataService::retrieveGrpVersion(const RsGxsGrpId &grpId){
std::set<RsNxsGrp*> grps;
retrieveGrpVersions(grpId.grpId, grps, false);
RsNxsGrp* grp = NULL;
if(!grps.empty()){
// find grp with comparable sign
std::set<RsNxsGrp*>::iterator sit = grps.begin();
for(; sit != grps.end(); sit++){
grp = *sit;
if(!memcmp(grp->adminSign.signData.bin_data, grpId.adminSign.signData.bin_data,
grpId.adminSign.signData.bin_len)){
break;
}
grp = NULL;
}
if(grp){
grps.erase(grp);
// release memory for non matching grps
for(sit = grps.begin(); sit != grps.end(); sit++)
delete *sit;
}
} }
return grp; return 1;
} }
int RsDataService::resetDataStore()
int RsDataService::resetDataStore(){ {
#ifdef RS_DATA_SERVICE_DEBUG #ifdef RS_DATA_SERVICE_DEBUG
std::cerr << "resetDataStore() " << std::endl; std::cerr << "resetDataStore() " << std::endl;
#endif #endif
std::map<std::string, RsNxsGrp*> grps; std::map<std::string, RsNxsGrp*> grps;
retrieveGrps(grps, false);
retrieveNxsGrps(grps, false);
std::map<std::string, RsNxsGrp*>::iterator mit std::map<std::string, RsNxsGrp*>::iterator mit
= grps.begin(); = grps.begin();
// remove all grp msgs files from service dir
for(; mit != grps.end(); mit++){ for(; mit != grps.end(); mit++){
std::string file = mServiceDir + "/" + mit->first; std::string file = mServiceDir + "/" + mit->first;
std::string msgFile = file + "-msgs"; std::string msgFile = file + "-msgs";
@ -490,19 +671,33 @@ int RsDataService::resetDataStore(){
} }
mDb->closeDb(); mDb->closeDb();
remove(mDbName.c_str()); remove(mDbName.c_str()); // remove db file
// recreate database
initialise(); initialise();
return 1; return 1;
} }
int RsDataService::removeGroups(const std::list<RsGxsGrpId> &grpIds){ int RsDataService::removeGroups(const std::vector<std::string> &grpIds)
{
return 0; return 0;
} }
int RsDataService::removeMsgs(const std::list<RsGxsMsgId> &msgIds){ int RsDataService::updateGroupMetaData(GrpLocMetaData *meta)
{
return 0;
}
int RsDataService::updateMessageMetaData(MsgLocMetaData *metaData)
{
return 0;
}
int RsDataService::removeMsgs(const std::string grpId, const std::vector<std::string> &msgIds)
{
return 0; return 0;
} }
@ -510,15 +705,8 @@ uint32_t RsDataService::cacheSize() const {
return 0; return 0;
} }
int RsDataService::setCacheSize(uint32_t size) { int RsDataService::setCacheSize(uint32_t size)
{
return 0; return 0;
} }
int RsDataService::searchGrps(RsGxsSearch *search, std::list<RsGxsSrchResGrpCtx *> &result) {
return 0;
}
int RsDataService::searchMsgs(RsGxsSearch *search, std::list<RsGxsSrchResMsgCtx *> &result) {
return 0;
}

122
libretroshare/src/gxs/rsdataservice.h
View file

@ -13,67 +13,52 @@ public:
virtual ~RsDataService(); virtual ~RsDataService();
/*! /*!
* Retrieves latest version of msgs for a service * Retrieves all msgs
* @param msgIds ids of messagesto retrieve * @param reqIds requested msg ids (grpId,msgId), leave msg list empty to get all msgs for the grp
* @param msg result of msg retrieval * @param msg result of msg retrieval
* @param cache whether to store retrieval in memory for faster later retrieval * @param cache whether to store results of this retrieval in memory for faster later retrieval
* @return error code * @return error code
*/ */
int retrieveMsgs(const std::string& grpId, std::map<std::string, RsNxsMsg*>& msg, bool cache); int retrieveNxsMsgs(const GxsMsgReq& reqIds, GxsMsgResult& msg, bool cache);
/*! /*!
* Retrieves latest version of groups for a service * Retrieves all groups stored (most current versions only)
* @param grpId the Id of the groups to retrieve * @param grp retrieved groups
* @param grp results of retrieval
* @param cache whether to store retrieval in mem for faster later retrieval * @param cache whether to store retrieval in mem for faster later retrieval
* @return error code * @return error code
*/ */
int retrieveGrps(std::map<std::string, RsNxsGrp*>& grp, bool cache); int retrieveNxsGrps(std::map<std::string, RsNxsGrp*>& grp, bool cache);
/*! /*!
* Retrieves all the versions of a group * Retrieves meta data of all groups stored (most current versions only)
* @param grpId the id of the group to get versions for * @param cache whether to store retrieval in mem for faster later retrieval
* @param cache whether to store the result in memory * @return error code
* @return errCode
*/ */
int retrieveGrpVersions(const std::string &grpId, std::set<RsNxsGrp *> &grp, bool cache); int retrieveGxsGrpMetaData(std::map<std::string, RsGxsGrpMetaData*>& grp);
/*! /*!
* @param grpId the id of the group to retrieve * Retrieves meta data of all groups stored (most current versions only)
* @return NULL if group does not exist or pointer to grp if found * @param grpIds grpIds for which to retrieve meta data
* @param msgMeta meta data result as map of grpIds to array of metadata for that grpId
* @param cache whether to store retrieval in mem for faster later retrieval
* @return error code
*/ */
RsNxsGrp* retrieveGrpVersion(const RsGxsGrpId& grpId); int retrieveGxsMsgMetaData(const std::vector<std::string>& grpIds, GxsMsgMetaResult& msgMeta);
/*! /*!
* remove msgs in data store listed in msgIds param * remove msgs in data store
* @param grpId group Id of message to be removed
* @param msgIds ids of messages to be removed * @param msgIds ids of messages to be removed
* @return error code * @return error code
*/ */
int removeMsgs(const std::list<RsGxsMsgId>& msgIds); int removeMsgs(const std::string grpId, const std::vector<std::string>& msgIds);
/*! /*!
* remove groups in data store listed in grpIds param * remove groups in data store listed in grpIds param
* @param grpIds ids of groups to be removed * @param grpIds ids of groups to be removed
* @return error code * @return error code
*/ */
int removeGroups(const std::list<RsGxsGrpId>& grpIds); int removeGroups(const std::vector<std::string>& grpIds);
/*!
* allows for more complex queries specific to the service
* @param search generally stores parameters needed for query
* @param msgId is set with msg ids which satisfy the gxs search
* @return error code
*/
int searchMsgs(RsGxsSearch* search, std::list<RsGxsSrchResMsgCtx*>& result);
/*!
* allows for more complex queries specific to the associated service
* @param search generally stores parameters needed for query
* @param msgId is set with msg ids which satisfy the gxs search
* @return error code
*/
int searchGrps(RsGxsSearch* search, std::list<RsGxsSrchResGrpCtx*>& result);
/*! /*!
* @return the cache size set for this RsGeneralDataService in bytes * @return the cache size set for this RsGeneralDataService in bytes
@ -83,43 +68,92 @@ public:
/*! /*!
* @param size size of cache to set in bytes * @param size size of cache to set in bytes
*/ */
virtual int setCacheSize(uint32_t size); int setCacheSize(uint32_t size);
/*! /*!
* Stores a list signed messages into data store * Stores a list of signed messages into data store
* @param msg list of signed messages to store * @param msg map of message and decoded meta data information
* @return error code * @return error code
*/ */
int storeMessage(std::set<RsNxsMsg*>& msg); int storeMessage(std::map<RsNxsMsg*, RsGxsMsgMetaData*>& msg);
/*! /*!
* Stores a list of groups in data store * Stores a list of groups in data store
* @param msg list of messages * @param grp map of group and decoded meta data
* @return error code * @return error code
*/ */
int storeGroup(std::set<RsNxsGrp*>& grp); int storeGroup(std::map<RsNxsGrp*, RsGxsGrpMetaData*>& grp);
/*!
* @param metaData The meta data item to update
* @return error code
*/
int updateMessageMetaData(MsgLocMetaData* metaData);
/*!
* @param metaData The meta data item to update
* @return error code
*/
int updateGroupMetaData(GrpLocMetaData* meta);
/*! /*!
* Completely clear out data stored in * Completely clear out data stored in
* this data store and returns this to a state * and returns this to a state
* as it was when first constructed * as it was when first constructed
* This also clears any data store items created in service directory * @return error code
*/ */
int resetDataStore(); int resetDataStore();
private: private:
/*!
* Retrieves all the msg results from a cursor
* @param c cursor to result set
* @param msgs messages retrieved from cursor are stored here
*/
void retrieveMessages(RetroCursor* c, std::vector<RsNxsMsg*>& msgs);
/*!
* extracts a msg meta item from a cursor at its
* current position
*/
RsGxsMsgMetaData* getMsgMeta(RetroCursor& c);
/*!
* extracts a grp meta item from a cursor at its
* current position
*/
RsGxsGrpMetaData* getGrpMeta(RetroCursor& c);
/*!
* extracts a msg item from a cursor at its
* current position
*/
RsNxsMsg* getMessage(RetroCursor& c); RsNxsMsg* getMessage(RetroCursor& c);
/*!
* extracts a grp item from a cursor at its
* current position
*/
RsNxsGrp* getGroup(RetroCursor& c); RsNxsGrp* getGroup(RetroCursor& c);
/*!
* Creates an sql database and its associated file
* also creates the message and groups table
*/
void initialise(); void initialise();
private: private:
RetroDb* mDb; RetroDb* mDb;
std::list<std::string> msgColumns; std::list<std::string> msgColumns;
std::list<std::string> msgMetaColumns;
std::list<std::string> grpColumns; std::list<std::string> grpColumns;
std::list<std::string> grpMetaColumns;
std::string mServiceDir, mDbName; std::string mServiceDir, mDbName;
uint16_t mServType; uint16_t mServType;

92
libretroshare/src/gxs/rsgds.h
View file

@ -34,6 +34,7 @@
#include "serialiser/rsgxsitems.h" #include "serialiser/rsgxsitems.h"
#include "serialiser/rsnxsitems.h" #include "serialiser/rsnxsitems.h"
#include "gxs/rsgxsdata.h"
class RsGxsSearchModule { class RsGxsSearchModule {
@ -47,6 +48,17 @@ public:
}; };
class MsgLocMetaData {
};
class GrpLocMetaData {
};
typedef std::map<std::string, std::set<std::string> > GxsMsgReq; // <grpId, msgIds>
typedef std::map<std::string, std::vector<RsNxsMsg*> > GxsMsgResult; // <grpId, msgs>
typedef std::map<std::string, std::vector<RsGxsMsgMetaData*> > GxsMsgMetaResult; // <grpId, msg metadatas>
/*! /*!
* The main role of GDS is the preparation and handing out of messages requested from * The main role of GDS is the preparation and handing out of messages requested from
@ -74,67 +86,54 @@ class RsGeneralDataService
public: public:
virtual ~RsGeneralDataService(){return;}; virtual ~RsGeneralDataService(){return;}
/*!
* Retrieves signed message
* @param grpId
* @param msg result of msg retrieval
* @param cache whether to store retrieval in memory for faster later retrieval
* @return error code
*/
virtual int retrieveMsgs(const std::string& grpId, std::map<std::string, RsNxsMsg*>& msg, bool cache) = 0;
/*! /*!
* Retrieves a group item by grpId * Retrieves all msgs
* @param grpId the Id of the groups to retrieve * @param reqIds requested msg ids (grpId,msgId), leave msg list empty to get all msgs for the grp
* @param grp results of retrieval * @param msg result of msg retrieval
* @param cache whether to store results of this retrieval in memory for faster later retrieval
* @return error code
*/
virtual int retrieveNxsMsgs(const GxsMsgReq& reqIds, GxsMsgResult& msg, bool cache) = 0;
/*!
* Retrieves all groups stored
* @param grp retrieved groups
* @param cache whether to store retrieval in mem for faster later retrieval * @param cache whether to store retrieval in mem for faster later retrieval
* @return error code * @return error code
*/ */
virtual int retrieveGrps(std::map<std::string, RsNxsGrp*>& grp, bool cache) = 0; virtual int retrieveNxsGrps(std::map<std::string, RsNxsGrp*>& grp, bool cache) = 0;
/*! /*!
* @param grpId the id of the group to get versions for * Retrieves meta data of all groups stored (most current versions only)
* @param cache whether to store the result in memory * @param cache whether to store retrieval in mem for faster later retrieval
* @param errCode
*/
virtual int retrieveGrpVersions(const std::string& grpId, std::set<RsNxsGrp*>& grp, bool cache) = 0;
/*!
* @param grpId the id of the group to retrieve
* @return NULL if group does not exist or pointer to grp if found
*/
virtual RsNxsGrp* retrieveGrpVersion(const RsGxsGrpId& grpId) = 0;
/*!
* allows for more complex queries specific to the service
* @param search generally stores parameters needed for query
* @param msgId is set with msg ids which satisfy the gxs search
* @return error code * @return error code
*/ */
virtual int searchMsgs(RsGxsSearch* search, std::list<RsGxsSrchResMsgCtx*>& result) = 0; virtual int retrieveGxsGrpMetaData(std::map<std::string, RsGxsGrpMetaData*>& grp) = 0;
/*! /*!
* allows for more complex queries specific to the associated service * Retrieves meta data of all groups stored (most current versions only)
* @param search generally stores parameters needed for query * @param grpIds grpIds for which to retrieve meta data
* @param msgId is set with msg ids which satisfy the gxs search * @param msgMeta meta data result as map of grpIds to array of metadata for that grpId
* @param cache whether to store retrieval in mem for faster later retrieval
* @return error code * @return error code
*/ */
virtual int searchGrps(RsGxsSearch* search, std::list<RsGxsSrchResGrpCtx*>& result) = 0; virtual int retrieveGxsMsgMetaData(const std::vector<std::string>& grpIds, GxsMsgMetaResult& msgMeta) = 0;
/*! /*!
* remove msgs in data store listed in msgIds param * remove msgs in data store listed in msgIds param
* @param msgIds ids of messages to be removed * @param msgIds ids of messages to be removed
* @return error code * @return error code
*/ */
virtual int removeMsgs(const std::list<RsGxsMsgId>& msgIds) = 0; virtual int removeMsgs(const std::string grpId, const std::vector<std::string>& msgIds) = 0;
/*! /*!
* remove groups in data store listed in grpIds param * remove groups in data store listed in grpIds param
* @param grpIds ids of groups to be removed * @param grpIds ids of groups to be removed
* @return error code * @return error code
*/ */
virtual int removeGroups(const std::list<RsGxsGrpId>& grpIds) = 0; virtual int removeGroups(const std::vector<std::string>& grpIds) = 0;
/*! /*!
* @return the cache size set for this RsGeneralDataService in bytes * @return the cache size set for this RsGeneralDataService in bytes
@ -147,18 +146,29 @@ public:
virtual int setCacheSize(uint32_t size) = 0; virtual int setCacheSize(uint32_t size) = 0;
/*! /*!
* Stores a list signed messages into data store * Stores a list of signed messages into data store
* @param msg list of signed messages to store * @param msg map of message and decoded meta data information
* @return error code * @return error code
*/ */
virtual int storeMessage(std::set<RsNxsMsg*>& msg) = 0; virtual int storeMessage(std::map<RsNxsMsg*, RsGxsMsgMetaData*>& msg);
/*! /*!
* Stores a list of groups in data store * Stores a list of groups in data store
* @param msg list of messages * @param grp map of group and decoded meta data
* @return error code * @return error code
*/ */
virtual int storeGroup(std::set<RsNxsGrp*>& grp) = 0; virtual int storeGroup(std::map<RsNxsGrp*, RsGxsGrpMetaData*>& grp);
/*!
* @param metaData
*/
virtual int updateMessageMetaData(MsgLocMetaData* metaData) = 0;
/*!
* @param metaData
*/
virtual int updateGroupMetaData(GrpLocMetaData* meta) = 0;
/*! /*!

250
libretroshare/src/gxs/rsgxs.h
View file

@ -50,6 +50,17 @@
typedef uint64_t RsGroupId ; typedef uint64_t RsGroupId ;
class RsTokReqOptions
{
public:
RsTokReqOptions() { mOptions = 0; mBefore = 0; mAfter = 0; }
uint32_t mOptions;
time_t mBefore;
time_t mAfter;
};
/*! /*!
@ -97,75 +108,37 @@ public:
virtual uint16_t getServiceType() const = 0; virtual uint16_t getServiceType() const = 0;
/*! /*!
* Request group, not intialising version member of RsGxsGrpId * Request group information
* results in the latest version of groups being returned * @param token this initialised with a token that can be redeemed for this request
* @return token for request * @param ansType type of group result wanted, summary
* @param opts token options
* @param groupIds list of group ids wanted, leaving this empty will result in a request for only list of group ids for the service
* @return false if request failed, true otherwise
* @see receiveGrp() * @see receiveGrp()
*/ */
int requestGrps(); bool requestGroupInfo(uint32_t &token, uint32_t ansType, const RsTokReqOptions &opts, const std::list<std::string> &groupIds);
/*! /*!
* Request group, not intialising version member of RsGxsGrpId * Request message information for a list of groups
* results in the latest version of group being returned * @param token this initialised with a token that can be redeemed for this request
* @return token for request * @param ansType type of msg info result
* @see receiveGrpList() * @param opts token options
* @param groupIds groups ids for which message info will be requested
* @return false if request failed, true otherwise
* @see receiveGrp()
*/ */
int requestSubscribedGrps(); virtual bool requestMsgInfo(uint32_t &token, uint32_t ansType, const RsTokReqOptions &opts, const std::list<std::string> &groupIds);
/*! /*!
* Request all versions of a group * Request message information for a list of groups
* @param grpId group id to request version for * @param token this initialised with a token that can be redeemed for this request
* @return token for request * @param ansType type of msg info result
* @param opts token options
* @param groupIds groups ids for which message info will be requested
* @return false if request failed, true otherwise
* @see receiveGrp()
*/ */
int requestAllGrpVersions(const std::string& grpId); bool requestMsgRelatedInfo(uint32_t &token, uint32_t ansType, const RsTokReqOptions &opts, const std::list<std::string> &msgIds);
/*!
* Event call back from Gxs runner
* after requested Grp(s) have been retrieved
* @param token the token to be redeemed
* @param errCode error code, can be exchanged for error string
* @param grps list of groups associated to request token
*/
virtual void receiveGrp(int token, int errCode, std::set<RsGxsGroup*>& grps) = 0;
/*************** Start: Msg request receive API ********************/
/* Messages a level below grps on the hiearchy hence group requests */
/* are intrinsically linked to their grp Id */
/*!
* request latest version of messages for groups
* listed
* @param grpIds list of grpIds to get msgs for
* @return token for request
* @see receiveMsg()
*/
int requestGrpMsgs(const std::list<std::string>& grpIds);
/*!
* request latest version of messages for group
* @param grpIds list of grpIds to get msgs for
* @return token for request
* @see receiveMsg()
*/
int requestAllMsgVersions(const std::list<RsGxsMsgId>& msgIds);
/*!
*
*
*/
int requestMsgVersion(const RsGxsMsgId& msgId);
/*!
* Event call back from GxsRunner
* after request msg(s) have been received
* @param token token to be redeemed
*/
virtual void receiveMsg(int token, int errCode, std::set<RsGxsMsg*>& msgs) = 0;
/*************** End: Msg request receive API ********************/
/*********** Start: publication *****************/ /*********** Start: publication *****************/
@ -207,27 +180,6 @@ public:
/*********** End: publication *****************/ /*********** End: publication *****************/
/*************************************************************************/
// The main idea here is each RsGroup needs permission set for each RsGxsGroup
// Thus a
// This is a configuration thing.
/*************************************************************************/
/*********** Start: groups *****************/
/*!
* This says listed group can are only ones that can
* share grp/msgs between themselves for grpId
* Default behaviour on group sharing is share with between all peers
* @param rsGrpId list of group id sharing will be allowed
* @param grpId groupId that share behaviour is being set
* @return status token to be redeemed
*/
int setShareGroup(const std::list<RsGroupId>& rsGrpId, const std::string grpId);
/*********** End: Identity control and groups *****************/
/****************************************************************************************************/ /****************************************************************************************************/
// Interface for Message Read Status // Interface for Message Read Status
// At the moment this is overloaded to handle autodownload flags too. // At the moment this is overloaded to handle autodownload flags too.
@ -241,7 +193,7 @@ public:
* @param GrpMsgMap flags this msg,version pair as read * @param GrpMsgMap flags this msg,version pair as read
* @param read set to true for read and false for unread * @param read set to true for read and false for unread
*/ */
int flagMsgRead(const RsGxsMsgId& msgId, bool read) ; int flagMsgRead(const std::string& msgId, bool read) ;
/*! /*!
@ -266,32 +218,7 @@ public:
* and not circulated. Entry will later be removed * and not circulated. Entry will later be removed
* once discard age is reached * once discard age is reached
*/ */
int requestDeleteGrp(const RsGxsGroup& grp); bool requestDeleteGrp(uint32_t& token, const RsGxsGroup& grp);
/******************* Start: Configuration *************************/
/*!
* How long to keep subscribed groups
* @param length how long to keep group in seconds
*/
int setSubscribedGroupDiscardAge(uint32_t length);
/*!
* How long to keep unsubscribed groups
* @param length how long to keep groups in seconds
* @return status token to be redeemed
* @see statusMsg()
*/
int setUnsubscribedGrpDiscardAge(uint32_t length);
/*!
* How long to keep messages, group discard age supercedes this \n
* discard age
* @param length how long to keep messages in seconds
*/
int setMsgDiscardAge(uint32_t length);
/*! /*!
@ -300,7 +227,7 @@ public:
* @param subscribe set to false to unsubscribe and true otherwise * @param subscribe set to false to unsubscribe and true otherwise
* @return token to redeem * @return token to redeem
*/ */
int requestSubscribeToGrp(const std::string& grpId, bool subscribe); bool requestSubscribeToGrp(uint32_t token, const std::string& grpId, bool subscribe);
public: public:
@ -310,7 +237,7 @@ public:
* @param errCode error code, can be exchanged for error string * @param errCode error code, can be exchanged for error string
* @param gxsStatus the status of subscription request * @param gxsStatus the status of subscription request
*/ */
virtual void receiveSubscribeToGrp(int token, int errCode) = 0; virtual void receiveSubscribeToGrp(int token, int errCode);
/*! /*!
* *
@ -328,7 +255,7 @@ public:
* have been updated or newly arrived * have been updated or newly arrived
* @param grpId ids of groups that have changed or newly arrived * @param grpId ids of groups that have changed or newly arrived
*/ */
virtual void notifyGroupChanged(std::list<std::string> grpIds) = 0; virtual void notifyGroupChanged(std::list<std::string> grpIds);
/*! /*!
@ -336,108 +263,27 @@ public:
* have been updated or newly arrived * have been updated or newly arrived
* @param msgId ids of msgs that have changed or newly arrived * @param msgId ids of msgs that have changed or newly arrived
*/ */
virtual void notifyMsgChanged(std::list<RsGxsMsgId> msgId) = 0; virtual void notifyMsgChanged(std::list<std::string> msgId);
/****************** End: Notifications from event runner ***************/ /****************** End: Notifications from event runner ***************/
/****************** Start: Search from event runner ***************/
// Users can either search groups or messages // Users can either search groups or messages
/*!
* Users
* Some standard search terms are supported
* @param term this allows users to search their local storage defined terms
* @return token to redeem search
*/
int requestLocalSearch(RsGxsSearch* term);
/*! /* Generic Lists */
* bool getGroupList(const uint32_t &token, std::list<std::string> &groupIds);
* @param token bool getMsgList(const uint32_t &token, std::list<std::string> &msgIds);
* @param errCode error code, can be exchanged for error string
* @param grpIds list of grp ids
*/
virtual void receiveLocalSearchGrps(int token, int errCode, std::list<RsGxsGroup*>& grps);
/*!
*
* @param token the request token to be redeemed
* @param errCode error code, can be exchanged for error string
* @param msgIds the message ids that contain contain search term
*/
virtual void receiveLocalSearchMsgs(int token, int errCode, std::list<RsGxsMsg*> &msgs) = 0;
/*!
*
* @param token request token to be redeemed
* @param errCode error code, can be exchanged for error string
* @param grps
*/
virtual void receiveRemoteSearchGrps(int token, int errCode, std::list<RsGxsGroup*>& grps) = 0;
/*!
*
* @param token the request token to be redeemed
* @param errCode error code, can be exchanged for error string
* @param msgIds
*/
virtual void recieveRemoteSearchMsgs(int token, int errCode, std::list<RsGxsMsg*>& msgs) = 0;
/* the following are protected to prevent RsGxsNetService calling below
* and causing infinite recursion
*/
// Remote Search...(2 hops ?)
/*!
*
* @param term This contains the search term
* @param hops how many hops from your immediate peer on the network for search
* @param delay lenght of time search should persist (if you are online search will be saved \n
* delay seconds, max is 2 days
* @return token to redeem search
*/
int requestRemoteSearchGrps(RsGxsSearch* term, uint32_t hops, uint32_t delay, bool immediate);
// Remote Search...(2 hops ?)
/*!
*
* @param term This contains the search term
* @param hops how many hops from your immediate peer on the network for search
* @param delay lenght of time search should persist (if you are online search will be saved \n
* delay seconds, max is 2 days
* @return token to redeem search
*/
int requestRemoteSearchMsgs(RsGxsSearch* term, uint32_t hops, uint32_t delay, bool immediate);
/*!
* Note if parent group is not present this will be requested \n
* by the event runner
* @param msgIds the ids of the remote messages being requested
* @return token to be redeemed
* @see receiveMsg()
*/
int requestRemoteMsg(std::list<RsGxsMsgId>& msgIds);
/*! /* Poll */
* @param grpIds the ids of the group being requested uint32_t requestStatus(const uint32_t token);
* @return token to be redeemed
* @see receiveGrp()
*/
int requestRemoteGrp(std::list<RsGxsGrpId>& grpIds);
/****************** End: Search from event runner ***************/ /* Cancel Request */
bool cancelRequest(const uint32_t &token);
/*! bool groupShareKeys(const std::string &groupId, std::list<std::string>& peers);
* @param msgIds ids of messages to be deleted
* @return token to be redeemed
*/
virtual int deleteRemoteMsg(std::list<RsGxsMsgId>& msgIds);
virtual int deleteRemoteGrp(std::list<RsGxsGrpId>& grpIds);
}; };
#endif // RSGXS_H #endif // RSGXS_H

176
libretroshare/src/gxs/rsgxsdata.cc Normal file
View file

@ -0,0 +1,176 @@
#include "rsgxsdata.h"
#include "serialiser/rsbaseserial.h"
RsGxsGrpMetaData::RsGxsGrpMetaData()
{
}
uint32_t RsGxsGrpMetaData::serial_size()
{
uint32_t s = 8; // header size
s += GetTlvStringSize(mGroupId);
s += GetTlvStringSize(mOrigGrpId);
s += GetTlvStringSize(mGroupName);
s += 4;
s += 4;
s += GetTlvStringSize(mAuthorId);
s += adminSign.TlvSize();
s += keys.TlvSize();
s += idSign.TlvSize();
return s;
}
bool RsGxsGrpMetaData::serialise(void *data, uint32_t &pktsize)
{
uint32_t tlvsize = serial_size() ;
uint32_t offset = 0;
if (pktsize < tlvsize)
return false; /* not enough space */
pktsize = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, tlvsize, 0, tlvsize);
#ifdef GXS_DEBUG
std::cerr << "RsGxsGrpMetaData serialise()" << std::endl;
std::cerr << "RsGxsGrpMetaData serialise(): Header: " << ok << std::endl;
std::cerr << "RsGxsGrpMetaData serialise(): Size: " << tlvsize << std::endl;
#endif
/* skip header */
offset += 8;
ok &= SetTlvString(data, tlvsize, &offset, 0, mGroupId);
ok &= SetTlvString(data, tlvsize, &offset, 0, mOrigGrpId);
ok &= SetTlvString(data, tlvsize, &offset, 0, mGroupName);
ok &= setRawUInt32(data, tlvsize, &offset, mGroupFlags);
ok &= setRawUInt32(data, tlvsize, &offset, mPublishTs);
ok &= SetTlvString(data, tlvsize, &offset, 0, mAuthorId);
ok &= adminSign.SetTlv(data, tlvsize, &offset);
ok &= keys.SetTlv(data, tlvsize, &offset);
ok &= idSign.SetTlv(data, tlvsize, &offset);
return ok;
}
bool RsGxsGrpMetaData::deserialise(void *data, uint32_t &pktsize)
{
uint32_t offset = 8; // skip the header
uint32_t rssize = getRsItemSize(data);
bool ok = true ;
ok &= rssize != pktsize;
if(!ok) return false;
ok &= GetTlvString(data, pktsize, &offset, 0, mGroupId);
ok &= GetTlvString(data, pktsize, &offset, 0, mOrigGrpId);
ok &= GetTlvString(data, pktsize, &offset, 0, mOrigGrpId);
ok &= getRawUInt32(data, pktsize, &offset, &mGroupFlags);
ok &= getRawUInt32(data, pktsize, &offset, &mPublishTs);
ok &= GetTlvString(data, pktsize, &offset, 0, mAuthorId);
ok &= adminSign.GetTlv(data, pktsize, &offset);
ok &= keys.SetTlv(data, pktsize, &offset);
ok &= idSign.SetTlv(data, pktsize, &offset);
return ok;
}
uint32_t RsGxsMsgMetaData::serial_size()
{
uint32_t s = 8; // header size
s += GetTlvStringSize(mGroupId);
s += GetTlvStringSize(mMsgId);
s += GetTlvStringSize(mThreadId);
s += GetTlvStringSize(mParentId);
s += GetTlvStringSize(mOrigMsgId);
s += pubSign.TlvSize();
s += idSign.TlvSize();
s += GetTlvStringSize(mMsgName);
s += 4;
s += 4;
return s;
}
bool RsGxsMsgMetaData::serialise(void *data, uint32_t *size)
{
uint32_t tlvsize = serial_size() ;
uint32_t offset = 0;
if (*size < tlvsize)
return false; /* not enough space */
*size = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, tlvsize, 0, tlvsize);
#ifdef GXS_DEBUG
std::cerr << "RsGxsGrpMetaData serialise()" << std::endl;
std::cerr << "RsGxsGrpMetaData serialise(): Header: " << ok << std::endl;
std::cerr << "RsGxsGrpMetaData serialise(): Size: " << tlvsize << std::endl;
#endif
/* skip header */
offset += 8;
ok &= SetTlvString(data, *size, &offset, 0, mGroupId);
ok &= SetTlvString(data, *size, &offset, 0, mMsgId);
ok &= SetTlvString(data, *size, &offset, 0, mThreadId);
ok &= SetTlvString(data, *size, &offset, 0, mParentId);
ok &= SetTlvString(data, *size, &offset, 0, mOrigMsgId);
ok &= pubSign.SetTlv(data, *size, &offset);
ok &= idSign.SetTlv(data, *size, &offset);
ok &= SetTlvString(data, *size, &offset, 0, mMsgName);
ok &= setRawUInt32(data, *size, &offset, mPublishTs);
ok &= setRawUInt32(data, *size, &offset, mMsgFlags);
return ok;
}
bool RsGxsMsgMetaData::deserialise(void *data, uint32_t *size)
{
uint32_t offset = 8; // skip the header
uint32_t rssize = getRsItemSize(data);
bool ok = true ;
ok &= rssize != *size;
if(!ok) return false;
ok &= GetTlvString(data, *size, &offset, 0, mGroupId);
ok &= GetTlvString(data, *size, &offset, 0, mMsgId);
ok &= GetTlvString(data, *size, &offset, 0, mThreadId);
ok &= GetTlvString(data, *size, &offset, 0, mParentId);
ok &= GetTlvString(data, *size, &offset, 0, mOrigMsgId);
ok &= pubSign.GetTlv(data, *size, &offset);
ok &= idSign.GetTlv(data, *size, &offset);
ok &= GetTlvString(data, *size, &offset, 0, mMsgName);
uint32_t t;
ok &= getRawUInt32(data, *size, &offset, &t);
mPublishTs = t;
ok &= getRawUInt32(data, *size, &offset, &mMsgFlags);
return ok;
}

85
libretroshare/src/gxs/rsgxsdata.h Normal file
View file

@ -0,0 +1,85 @@
#ifndef RSGXSMETA_H
#define RSGXSMETA_H
#include <string>
#include "serialiser/rsserial.h"
#include "serialiser/rstlvbase.h"
#include "serialiser/rstlvtypes.h"
#include "serialiser/rstlvkeys.h"
class RsGxsGrpMetaData
{
public:
RsGxsGrpMetaData();
bool deserialise(void *data, uint32_t &pktsize);
bool serialise(void* data, uint32_t &pktsize);
uint32_t serial_size();
std::string mGroupId;
std::string mOrigGrpId;
std::string mGroupName;
uint32_t mGroupFlags;
uint32_t mPublishTs;
std::string mAuthorId;
RsTlvKeySignature adminSign;
RsTlvSecurityKeySet keys;
RsTlvKeySignature idSign;
// BELOW HERE IS LOCAL DATA, THAT IS NOT FROM MSG.
uint32_t mSubscribeFlags;
uint32_t mPop; // HOW DO WE DO THIS NOW.
uint32_t mMsgCount; // ???
time_t mLastPost; // ???
uint32_t mGroupStatus;
};
class RsGxsMsgMetaData
{
public:
RsGxsMsgMetaData();
bool deserialise(void *data, uint32_t *size);
bool serialise(void* data, uint32_t *size);
uint32_t serial_size();
std::string mGroupId;
std::string mMsgId;
std::string mThreadId;
std::string mParentId;
std::string mOrigMsgId;
std::string mAuthorId;
RsTlvKeySignature pubSign;
RsTlvKeySignature idSign;
std::string mMsgName;
time_t mPublishTs;
uint32_t mMsgFlags; // Whats this for?
// BELOW HERE IS LOCAL DATA, THAT IS NOT FROM MSG.
// normally READ / UNREAD flags. LOCAL Data.
uint32_t mMsgStatus;
time_t mChildTs;
};
#endif // RSGXSMETA_H

39
libretroshare/src/gxs/rsgxsnetservice.cc
View file

@ -415,6 +415,7 @@ void RsGxsNetService::genReqMsgTransaction(NxsTransaction* tr)
std::list<RsNxsItem*>::iterator lit = tr->mItems.begin(); std::list<RsNxsItem*>::iterator lit = tr->mItems.begin();
// first get item list sent from transaction
for(; lit != tr->mItems.end(); lit++) for(; lit != tr->mItems.end(); lit++)
{ {
RsNxsSyncMsgItem* item = dynamic_cast<RsNxsSyncMsgItem*>(*lit); RsNxsSyncMsgItem* item = dynamic_cast<RsNxsSyncMsgItem*>(*lit);
@ -424,7 +425,7 @@ void RsGxsNetService::genReqMsgTransaction(NxsTransaction* tr)
}else }else
{ {
#ifdef NXS_NET_DEBUG #ifdef NXS_NET_DEBUG
std::cerr << "RsGxsNetService::genReqMsgTransaction(): item failed to caste to RsNxsSyncMsgItem* " std::cerr << "RsGxsNetService::genReqMsgTransaction(): item failed cast to RsNxsSyncMsgItem* "
<< std::endl; << std::endl;
#endif #endif
delete item; delete item;
@ -432,22 +433,36 @@ void RsGxsNetService::genReqMsgTransaction(NxsTransaction* tr)
} }
} }
RsNxsSyncMsgItem* item = msgItemL.front();
const std::string& grpId = item->grpId;
std::map<std::string, RsNxsMsg*> msgMap;
mDataStore->retrieveMsgs(grpId, msgMap, false);
// now do compare and add loop // get grp id for this transaction
std::list<RsNxsSyncMsgItem*>::iterator llit = msgItemL.begin(); RsNxsSyncMsgItem* item = msgItemL.front();
std::list<RsNxsItem*> reqList; const std::string& grpId = item->grpId;
std::vector<std::string> grpIdV;
grpIdV.push_back(grpId);
GxsMsgMetaResult result;
mDataStore->retrieveGxsMsgMetaData(grpIdV, result);
std::vector<RsGxsMsgMetaData*> &msgMetaV = result[grpId];
std::vector<RsGxsMsgMetaData*>::const_iterator vit = msgMetaV.begin();
std::set<std::string> msgIdSet;
// put ids in set for each searching
for(; vit != msgMetaV.end(); vit++)
msgIdSet.insert((*vit)->mMsgId);
// get unique id for this transaction
uint32_t transN = getTransactionId(); uint32_t transN = getTransactionId();
// now do compare and add loop
std::list<RsNxsSyncMsgItem*>::iterator llit = msgItemL.begin();
std::list<RsNxsItem*> reqList;
for(; llit != msgItemL.end(); llit++) for(; llit != msgItemL.end(); llit++)
{ {
const std::string& msgId = (*llit)->msgId; const std::string& msgId = (*llit)->msgId;
if(msgMap.find(msgId) == msgMap.end()){ if(msgIdSet.find(msgId) == msgIdSet.end()){
RsNxsSyncMsgItem* msgItem = new RsNxsSyncMsgItem(mServType); RsNxsSyncMsgItem* msgItem = new RsNxsSyncMsgItem(mServType);
msgItem->grpId = grpId; msgItem->grpId = grpId;
msgItem->msgId = msgId; msgItem->msgId = msgId;
@ -506,8 +521,8 @@ void RsGxsNetService::genReqGrpTransaction(NxsTransaction* tr)
RsNxsSyncGrpItem* item = grpItemL.front(); RsNxsSyncGrpItem* item = grpItemL.front();
const std::string& grpId = item->grpId; const std::string& grpId = item->grpId;
std::map<std::string, RsNxsGrp*> grpMap; std::map<std::string, RsGxsGrpMetaData*> grpMetaMap;
mDataStore->retrieveGrps(grpMap, false); mDataStore->retrieveGxsGrpMetaData(grpMetaMap);
// now do compare and add loop // now do compare and add loop
std::list<RsNxsSyncGrpItem*>::iterator llit = grpItemL.begin(); std::list<RsNxsSyncGrpItem*>::iterator llit = grpItemL.begin();
@ -519,7 +534,7 @@ void RsGxsNetService::genReqGrpTransaction(NxsTransaction* tr)
{ {
const std::string& grpId = (*llit)->grpId; const std::string& grpId = (*llit)->grpId;
if(grpMap.find(grpId) == grpMap.end()){ if(grpMetaMap.find(grpId) == grpMetaMap.end()){
RsNxsSyncGrpItem* grpItem = new RsNxsSyncGrpItem(mServType); RsNxsSyncGrpItem* grpItem = new RsNxsSyncGrpItem(mServType);
grpItem->grpId = grpId; grpItem->grpId = grpId;

4
libretroshare/src/gxs/rsgxsnetservice.h
View file

@ -111,7 +111,7 @@ public:
* @param peerId Id of peer * @param peerId Id of peer
* @param grpId id of group to request messages for * @param grpId id of group to request messages for
*/ */
void requestMessagesOfPeer(const std::string& peerId, const RsGxsGrpId& grpId){ return; } void requestMessagesOfPeer(const std::string& peerId, const std::string& grpId){ return; }
/*! /*!
* Initiates a search through the network * Initiates a search through the network
@ -154,7 +154,7 @@ public:
* @param enabled set to false to disable pause, and true otherwise * @param enabled set to false to disable pause, and true otherwise
* @return request token to be redeemed * @return request token to be redeemed
*/ */
int requestGrp(const std::list<RsGxsGrpId>& grpId, uint8_t hops){ return 0;} int requestGrp(const std::list<std::string>& grpId, uint8_t hops){ return 0;}

4
libretroshare/src/gxs/rsnxs.h
View file

@ -81,7 +81,7 @@ public:
* @param peerId Id of peer * @param peerId Id of peer
* @param grpId id of group to request messages for * @param grpId id of group to request messages for
*/ */
virtual void requestMessagesOfPeer(const std::string& peerId, const RsGxsGrpId& grpId) = 0; virtual void requestMessagesOfPeer(const std::string& peerId, const std::string& grpId) = 0;
/*! /*!
* Initiates a search through the network * Initiates a search through the network
@ -124,7 +124,7 @@ public:
* @param enabled set to false to disable pause, and true otherwise * @param enabled set to false to disable pause, and true otherwise
* @return request token to be redeemed * @return request token to be redeemed
*/ */
virtual int requestGrp(const std::list<RsGxsGrpId>& grpId, uint8_t hops) = 0; virtual int requestGrp(const std::list<std::string>& grpId, uint8_t hops) = 0;
}; };

21
libretroshare/src/libretroshare.pro
View file

@ -157,11 +157,9 @@ PUBLIC_HEADERS = retroshare/rsblogs.h \
retroshare/rsconfig.h retroshare/rsconfig.h
HEADERS += plugins/pluginmanager.h \ HEADERS += plugins/pluginmanager.h \
plugins/dlfcn_win32.h \ plugins/dlfcn_win32.h \
serialiser/rspluginitems.h \ serialiser/rspluginitems.h \
gxs/rsdataservice.h \ gxs/rsgxsdata.h
gxs/rsgxsflags.h \
gxs/rsgenexchange.h
HEADERS += $$PUBLIC_HEADERS HEADERS += $$PUBLIC_HEADERS
@ -666,8 +664,12 @@ newcache {
HEADERS += serialiser/rsnxsitems.h \ HEADERS += serialiser/rsnxsitems.h \
gxs/rsgds.h \ gxs/rsgds.h \
gxs/rsgxs.h \ gxs/rsgxs.h \
gxs/rsdataservice/h \ gxs/rsdataservice.h \
gxs/rsgxsnetservice.h gxs/rsgxsnetservice.h \
gxs/rsgxsflags.h \
gxs/rsgenexchange.h \
gxs/rsgenexchange.h \
gxs/rsnxsobserver.h
SOURCES += serialiser/rsnxsitems.cc \ SOURCES += serialiser/rsnxsitems.cc \
gxs/rsdataservice.cc \ gxs/rsdataservice.cc \
@ -703,4 +705,9 @@ SOURCES += services/p3photoservice.cc \
# rsserver/p3photo.cc \ # rsserver/p3photo.cc \
} }
SOURCES += \
SOURCES +=
SOURCES += \
gxs/rsgxsdata.cc

28
libretroshare/src/serialiser/rsgxsitems.h
View file

@ -34,6 +34,7 @@
#include "serialiser/rstlvbase.h" #include "serialiser/rstlvbase.h"
#include "serialiser/rstlvtypes.h" #include "serialiser/rstlvtypes.h"
#include "serialiser/rstlvkeys.h" #include "serialiser/rstlvkeys.h"
#include "gxs/rsgxsdata.h"
@ -50,26 +51,8 @@ public:
RsGxsMsg() : RsItem(0) {} RsGxsMsg() : RsItem(0) {}
virtual ~RsGxsMsg(){ return; } virtual ~RsGxsMsg(){ return; }
/***** Don not serialise or set these members *****/
std::string grpId; /// group id
std::string msgId; /// message id
uint32_t timeStamp; /// UTC time when created
std::string identity; /// identity associated with (no id means no signed)
/*!
* The purpose of the flag is to note
* If this message is an edit (note that edits only applies to
* signed msgs)
*/
uint32_t msgFlag;
/***** Don not serialise or set these members *****/
}; };
/*! /*!
* Base class used by client API * Base class used by client API
* for groups. * for groups.
@ -82,8 +65,6 @@ class RsGxsGroup : public RsItem
public: public:
/*** type of msgs ***/ /*** type of msgs ***/
RsGxsGroup(uint16_t servtype, uint8_t subtype) RsGxsGroup(uint16_t servtype, uint8_t subtype)
@ -91,13 +72,6 @@ public:
virtual ~RsGxsGroup() { return; } virtual ~RsGxsGroup() { return; }
std::string grpId; /// group id
std::string identity; /// identity associated with group
uint32_t timeStamp; /// UTC time
bool subscribed;
bool read;
/*! /*!
* Three thing flag represents: * Three thing flag represents:
* Is it signed by identity? * Is it signed by identity?

111
libretroshare/src/serialiser/rsnxsitems.cc
View file

@ -232,14 +232,9 @@ bool RsNxsSerialiser::serialiseNxsMsg(RsNxsMsg *item, void *data, uint32_t *size
ok &= setRawUInt32(data, *size, &offset, item->transactionNumber); ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSGID, item->msgId); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSGID, item->msgId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSGID, item->originalMsgId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->identity);
ok &= setRawUInt32(data, tlvsize, &offset, item->timeStamp);
ok &= setRawUInt32(data, tlvsize, &offset, item->msgFlag);
ok &= item->idSign.SetTlv(data, tlvsize, &offset);
ok &= item->publishSign.SetTlv(data, tlvsize, &offset);
ok &= item->msg.SetTlv(data, tlvsize, &offset); ok &= item->msg.SetTlv(data, tlvsize, &offset);
ok &= item->meta.SetTlv(data, *size, &offset);
if(offset != tlvsize){ if(offset != tlvsize){
@ -288,13 +283,8 @@ bool RsNxsSerialiser::serialiseNxsGrp(RsNxsGrp *item, void *data, uint32_t *size
// grp id // grp id
ok &= setRawUInt32(data, *size, &offset, item->transactionNumber); ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->identity);
ok &= setRawUInt32(data, tlvsize, &offset, item->grpFlag);
ok &= setRawUInt32(data, tlvsize, &offset, item->timeStamp);
ok &= item->idSign.SetTlv(data, tlvsize, &offset);
ok &= item->adminSign.SetTlv(data, tlvsize, &offset);
ok &= item->keys.SetTlv(data, tlvsize, &offset);
ok &= item->grp.SetTlv(data, tlvsize, &offset); ok &= item->grp.SetTlv(data, tlvsize, &offset);
ok &= item->meta.SetTlv(data, *size, &offset);
if(offset != tlvsize){ if(offset != tlvsize){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
@ -422,7 +412,7 @@ bool RsNxsSerialiser::serialiseNxsSyncGrpItem(RsNxsSyncGrpItem *item, void *data
if(*size < tlvsize){ if(*size < tlvsize){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem() size do not match" << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSyncm() size do not match" << std::endl;
#endif #endif
return false; return false;
} }
@ -436,16 +426,16 @@ bool RsNxsSerialiser::serialiseNxsSyncGrpItem(RsNxsSyncGrpItem *item, void *data
/* skip the header */ /* skip the header */
offset += 8; offset += 8;
/* RsNxsSyncGrpItem */ /* RsNxsSyncm */
ok &= setRawUInt32(data, *size, &offset, item->transactionNumber); ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
ok &= setRawUInt8(data, *size, &offset, item->flag); ok &= setRawUInt8(data, *size, &offset, item->flag);
ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= item->adminSign.SetTlv(data, *size, &offset); ok &= setRawUInt32(data, *size, &offset, item->publishTs);
if(offset != tlvsize){ if(offset != tlvsize){
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem( FAIL Size Error! " << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSyncm( FAIL Size Error! " << std::endl;
#endif #endif
ok = false; ok = false;
} }
@ -453,7 +443,7 @@ bool RsNxsSerialiser::serialiseNxsSyncGrpItem(RsNxsSyncGrpItem *item, void *data
#ifdef RSSERIAL_DEBUG #ifdef RSSERIAL_DEBUG
if (!ok) if (!ok)
{ {
std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem() NOK" << std::endl; std::cerr << "RsNxsSerialiser::serialiseNxsSyncm() NOK" << std::endl;
} }
#endif #endif
@ -558,13 +548,8 @@ RsNxsGrp* RsNxsSerialiser::deserialNxsGrp(void *data, uint32_t *size){
ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber)); ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_NAME, item->identity);
ok &= getRawUInt32(data, *size, &offset, &(item->grpFlag));
ok &= getRawUInt32(data, *size, &offset, &(item->timeStamp));
ok &= item->idSign.GetTlv(data, *size, &offset);
ok &= item->adminSign.GetTlv(data, *size, &offset);
ok &= item->keys.GetTlv(data, *size, &offset);
ok &= item->grp.GetTlv(data, *size, &offset); ok &= item->grp.GetTlv(data, *size, &offset);
ok &= item->meta.GetTlv(data, *size, &offset);
if (offset != rssize) if (offset != rssize)
{ {
@ -631,14 +616,9 @@ RsNxsMsg* RsNxsSerialiser::deserialNxsMsg(void *data, uint32_t *size){
ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber)); ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId); ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId);
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->originalMsgId);
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_NAME, item->identity); ok &= item->msg.GetTlv(data, *size, &offset);
ok &= getRawUInt32(data, *size, &offset, &(item->timeStamp)); ok &= item->meta.GetTlv(data, *size, &offset);
ok &= getRawUInt32(data, *size, &offset, &(item->msgFlag));
ok &= item->idSign.GetTlv(data, *size, &offset);
ok &= item->publishSign.GetTlv(data, *size, &offset);
ok &= item->msg.GetTlv(data, *size, &offset);;
if (offset != rssize) if (offset != rssize)
{ {
@ -772,7 +752,7 @@ RsNxsSyncGrpItem* RsNxsSerialiser::deserialNxsSyncGrpItem(void *data, uint32_t *
ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber)); ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
ok &= getRawUInt8(data, *size, &offset, &(item->flag)); ok &= getRawUInt8(data, *size, &offset, &(item->flag));
ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId); ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
ok &= item->adminSign.GetTlv(data, *size, &offset); ok &= getRawUInt32(data, *size, &offset, &(item->publishTs));
if (offset != rssize) if (offset != rssize)
{ {
@ -1020,13 +1000,8 @@ uint32_t RsNxsSerialiser::sizeNxsMsg(RsNxsMsg *item)
s += 4; // transaction number s += 4; // transaction number
s += GetTlvStringSize(item->grpId); s += GetTlvStringSize(item->grpId);
s += GetTlvStringSize(item->msgId); s += GetTlvStringSize(item->msgId);
s += GetTlvStringSize(item->identity);
s += GetTlvStringSize(item->originalMsgId);
s += 4; // msgFlag
s += 4; // timeStamp
s += item->publishSign.TlvSize();
s += item->idSign.TlvSize();
s += item->msg.TlvSize(); s += item->msg.TlvSize();
s += item->meta.TlvSize();
return s; return s;
} }
@ -1037,13 +1012,8 @@ uint32_t RsNxsSerialiser::sizeNxsGrp(RsNxsGrp *item)
s += 4; // transaction number s += 4; // transaction number
s += GetTlvStringSize(item->grpId); s += GetTlvStringSize(item->grpId);
s += GetTlvStringSize(item->identity);
s += 4; // grpFlag
s += 4; // timestamp
s += item->adminSign.TlvSize();
s += item->idSign.TlvSize();
s += item->keys.TlvSize();
s += item->grp.TlvSize(); s += item->grp.TlvSize();
s += item->meta.TlvSize();
return s; return s;
} }
@ -1067,9 +1037,9 @@ uint32_t RsNxsSerialiser::sizeNxsSyncGrpItem(RsNxsSyncGrpItem *item)
uint32_t s = 8; // header size uint32_t s = 8; // header size
s += 4; // transaction number s += 4; // transaction number
s += 4; // publishTs
s += 1; // flag s += 1; // flag
s += GetTlvStringSize(item->grpId); s += GetTlvStringSize(item->grpId);
s += item->adminSign.TlvSize();
return s; return s;
} }
@ -1124,27 +1094,16 @@ uint32_t RsNxsSerialiser::sizeNxsExtended(RsNxsExtended *item){
void RsNxsMsg::clear() void RsNxsMsg::clear()
{ {
msg.TlvClear(); msg.TlvClear();
grpId.clear(); meta.TlvClear();
msgId.clear();
msgFlag = 0;
timeStamp = 0;
publishSign.TlvClear();
idSign.TlvClear();
identity.clear();
originalMsgId.clear();
} }
void RsNxsGrp::clear() void RsNxsGrp::clear()
{ {
grpId.clear(); grpId.clear();
timeStamp = 0;
grp.TlvClear(); grp.TlvClear();
adminSign.TlvClear(); meta.TlvClear();
keys.TlvClear();
identity.clear();
grpFlag = 0;
idSign.TlvClear();
} }
void RsNxsSyncGrp::clear() void RsNxsSyncGrp::clear()
@ -1165,7 +1124,7 @@ void RsNxsSyncMsg::clear()
void RsNxsSyncGrpItem::clear() void RsNxsSyncGrpItem::clear()
{ {
flag = 0; flag = 0;
adminSign.TlvClear(); publishTs = 0;
grpId.clear(); grpId.clear();
} }
@ -1209,7 +1168,7 @@ std::ostream& RsNxsExtended::print(std::ostream &out, uint16_t indent){
printIndent(out , int_Indent); printIndent(out , int_Indent);
out << "type: " << type << std::endl; out << "type: " << type << std::endl;
printIndent(out , int_Indent); printIndent(out , int_Indent);
extData.print(out, indent); extData.print(out, int_Indent);
printRsItemEnd(out ,"RsNxsExtended", indent); printRsItemEnd(out ,"RsNxsExtended", indent);
@ -1244,8 +1203,7 @@ std::ostream& RsNxsSyncGrpItem::print(std::ostream &out, uint16_t indent)
printIndent(out , int_Indent); printIndent(out , int_Indent);
out << "grpId: " << grpId << std::endl; out << "grpId: " << grpId << std::endl;
printIndent(out , int_Indent); printIndent(out , int_Indent);
adminSign.print(out, indent); out << "publishTs: " << publishTs << std::endl;
printIndent(out , int_Indent);
printRsItemEnd(out , "RsNxsSyncGrpItem", indent); printRsItemEnd(out , "RsNxsSyncGrpItem", indent);
return out; return out;
@ -1277,17 +1235,10 @@ std::ostream& RsNxsGrp::print(std::ostream &out, uint16_t indent){
out << "grpId: " << grpId << std::endl; out << "grpId: " << grpId << std::endl;
printIndent(out , int_Indent); printIndent(out , int_Indent);
out << "timeStamp: " << timeStamp << std::endl; out << "grp: " << std::endl;
printIndent(out , int_Indent); grp.print(out, int_Indent);
out << "identity: " << identity << std::endl; out << "meta: " << std::endl;
printIndent(out , int_Indent); meta.print(out, int_Indent);
out << "grpFlag: " << grpFlag << std::endl;
out << "adminSign: " << std::endl;
adminSign.print(out, indent);
out << "idSign: " << std::endl;
idSign.print(out, indent);
out << "keys: " << std::endl;
keys.print(out, indent);
printRsItemEnd(out, "RsNxsGrp", indent); printRsItemEnd(out, "RsNxsGrp", indent);
return out; return out;
@ -1302,16 +1253,10 @@ std::ostream& RsNxsMsg::print(std::ostream &out, uint16_t indent){
printIndent(out , int_Indent); printIndent(out , int_Indent);
out << "grpId: " << grpId << std::endl; out << "grpId: " << grpId << std::endl;
printIndent(out , int_Indent); printIndent(out , int_Indent);
out << "msgFlag: " << msgFlag << std::endl; out << "msg: " << std::endl;
printIndent(out , int_Indent); msg.print(out, indent);
out << "identity: " << identity << std::endl; out << "meta: " << std::endl;
printIndent(out , int_Indent); meta.print(out, int_Indent);
out << "timeStamp: " << timeStamp << std::endl;
printIndent(out , int_Indent);
out << "pub sign: " << std::endl;
publishSign.print(out, indent);
out << "id sign: " << std::endl;
idSign.print(out, indent);
printRsItemEnd(out ,"RsNxsMsg", indent); printRsItemEnd(out ,"RsNxsMsg", indent);
return out; return out;

65
libretroshare/src/serialiser/rsnxsitems.h
View file

@ -111,8 +111,8 @@ class RsNxsTransac : public RsNxsItem {
public: public:
static const uint16_t FLAG_TRANS_MASK = 0xf; static const uint16_t FLAG_TRANS_MASK = 0xf;
static const uint16_t FLAG_TYPE_MASK = 0xff; static const uint16_t FLAG_TYPE_MASK = 0xff;
/** transaction **/ /** transaction **/
static const uint16_t FLAG_BEGIN_P1; static const uint16_t FLAG_BEGIN_P1;
@ -165,8 +165,9 @@ public:
uint8_t flag; // request or response uint8_t flag; // request or response
/// groups held by sending peer uint32_t publishTs; // to compare to Ts of receiving peer's grp of same id
RsTlvKeySignature adminSign;
/// grpId of grp held by sending peer
std::string grpId; std::string grpId;
}; };
@ -181,20 +182,22 @@ class RsNxsGrp : public RsNxsItem
public: public:
RsNxsGrp(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_GRP), grp(servtype) { clear(); return; } RsNxsGrp(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_GRP), grp(servtype), meta(servtype) { clear(); return; }
virtual void clear(); virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent); virtual std::ostream &print(std::ostream &out, uint16_t indent);
std::string grpId; /// group Id, needed to complete version Id (ncvi) std::string grpId; /// group Id, needed to complete version Id (ncvi)
uint32_t timeStamp; /// UTC time, ncvi
RsTlvBinaryData grp; /// actual group data RsTlvBinaryData grp; /// actual group data
RsTlvKeySignature adminSign; /// signature of admin (needed to complete version Id
RsTlvSecurityKeySet keys; /*!
std::string identity; * This should contains all the data
RsTlvKeySignature idSign; /// identity sign if applicable * which is not specific to the Gxs service data
uint32_t grpFlag; */
RsTlvBinaryData meta;
}; };
/*! /*!
@ -251,21 +254,25 @@ class RsNxsMsg : public RsNxsItem
{ {
public: public:
RsNxsMsg(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_MSG), msg(servtype) { clear(); return; } RsNxsMsg(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_MSG), msg(servtype), meta(servtype) { clear(); return; }
virtual void clear(); virtual void clear();
virtual std::ostream &print(std::ostream &out, uint16_t indent); virtual std::ostream &print(std::ostream &out, uint16_t indent);
std::string grpId; /// group id, forms part of version id std::string grpId; /// group id, forms part of version id
std::string msgId; /// msg id std::string msgId; /// msg id
std::string originalMsgId;
uint32_t msgFlag; /*!
uint32_t timeStamp; /// UTC time create, * This should contains all the data
* which is not specific to the Gxs service data
*/
RsTlvBinaryData meta;
/*!
* This contains Gxs specific data
* only client of API knows who to decode this
*/
RsTlvBinaryData msg; RsTlvBinaryData msg;
RsTlvKeySignature publishSign; /// publish signature
RsTlvKeySignature idSign; /// identity signature
std::string identity;
}; };
@ -445,24 +452,4 @@ private:
}; };
class RsGxsMsgId {
public:
std::string grpId;
std::string msgId;
RsTlvKeySignature idSign;
};
class RsGxsGrpId {
public:
std::string grpId;
RsTlvKeySignature adminSign;
};
#endif // RSNXSITEMS_H #endif // RSNXSITEMS_H

56
libretroshare/src/tests/serialiser/rsnxsitems_test.cc
View file

@ -11,26 +11,12 @@ INITTEST();
RsSerialType* init_item(RsNxsGrp& nxg) RsSerialType* init_item(RsNxsGrp& nxg)
{ {
nxg.clear();
randString(SHORT_STR, nxg.identity);
randString(SHORT_STR, nxg.grpId); randString(SHORT_STR, nxg.grpId);
nxg.timeStamp = rand()%23;
nxg.transactionNumber = rand()%23; nxg.transactionNumber = rand()%23;
nxg.grpFlag = rand()%242;
init_item(nxg.grp); init_item(nxg.grp);
init_item(nxg.meta);
init_item(nxg.adminSign);
init_item(nxg.idSign);
int nKey = rand()%12;
for(int i=0; i < nKey; i++){
nxg.keys.groupId = nxg.grpId;
std::string s;
RsTlvSecurityKey k;
init_item(k);
nxg.keys.keys[k.keyId] = k;
}
return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
} }
@ -38,15 +24,12 @@ RsSerialType* init_item(RsNxsGrp& nxg)
RsSerialType* init_item(RsNxsMsg& nxm) RsSerialType* init_item(RsNxsMsg& nxm)
{ {
nxm.clear();
randString(SHORT_STR, nxm.msgId); randString(SHORT_STR, nxm.msgId);
randString(SHORT_STR, nxm.grpId); randString(SHORT_STR, nxm.grpId);
randString(SHORT_STR, nxm.identity);
init_item(nxm.publishSign);
init_item(nxm.idSign);
init_item(nxm.msg); init_item(nxm.msg);
nxm.msgFlag = rand()%4252; init_item(nxm.meta);
nxm.timeStamp = rand()%246;
nxm.transactionNumber = rand()%23; nxm.transactionNumber = rand()%23;
return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
@ -55,7 +38,6 @@ RsSerialType* init_item(RsNxsMsg& nxm)
RsSerialType* init_item(RsNxsSyncGrp& rsg) RsSerialType* init_item(RsNxsSyncGrp& rsg)
{ {
rsg.clear(); rsg.clear();
rsg.flag = RsNxsSyncGrp::FLAG_USE_SYNC_HASH; rsg.flag = RsNxsSyncGrp::FLAG_USE_SYNC_HASH;
rsg.syncAge = rand()%2423; rsg.syncAge = rand()%2423;
randString(3124,rsg.syncHash); randString(3124,rsg.syncHash);
@ -82,9 +64,8 @@ RsSerialType* init_item(RsNxsSyncGrpItem& rsgl)
rsgl.flag = RsNxsSyncGrpItem::FLAG_RESPONSE; rsgl.flag = RsNxsSyncGrpItem::FLAG_RESPONSE;
rsgl.transactionNumber = rand()%23; rsgl.transactionNumber = rand()%23;
rsgl.publishTs = rand()%23;
randString(SHORT_STR, rsgl.grpId); randString(SHORT_STR, rsgl.grpId);
init_item(rsgl.adminSign);
return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
} }
@ -115,26 +96,11 @@ RsSerialType* init_item(RsNxsTransac& rstx){
bool operator==(const RsNxsGrp& l, const RsNxsGrp& r){ bool operator==(const RsNxsGrp& l, const RsNxsGrp& r){
if(!(l.adminSign == r.adminSign)) return false;
if(!(l.idSign == r.idSign)) return false;
if(l.timeStamp != r.timeStamp) return false;
if(l.grpFlag != r.grpFlag) return false;
if(l.identity != r.identity) return false;
if(l.grpId != r.grpId) return false; if(l.grpId != r.grpId) return false;
if(l.keys.groupId != r.keys.groupId) return false;
if(!(l.grp == r.grp) ) return false; if(!(l.grp == r.grp) ) return false;
if(!(l.meta == r.meta) ) return false;
if(l.transactionNumber != r.transactionNumber) return false; if(l.transactionNumber != r.transactionNumber) return false;
std::map<std::string, RsTlvSecurityKey>::const_iterator mit =
l.keys.keys.begin(), mit_end = l.keys.keys.end();
for(; mit != mit_end; mit++){
const RsTlvSecurityKey& lk = l.keys.keys.find(mit->first)->second;
const RsTlvSecurityKey& rk = r.keys.keys.find(mit->first)->second;
if(! ( lk == rk) ) return false;
}
return true; return true;
} }
@ -142,12 +108,8 @@ bool operator==(const RsNxsMsg& l, const RsNxsMsg& r){
if(l.msgId != r.msgId) return false; if(l.msgId != r.msgId) return false;
if(l.grpId != r.grpId) return false; if(l.grpId != r.grpId) return false;
if(l.identity != r.identity) return false;
if(l.timeStamp != r.timeStamp) return false;
if(l.msgFlag != r.msgFlag) return false;
if(! (l.msg == r.msg) ) return false; if(! (l.msg == r.msg) ) return false;
if(! (l.publishSign == r.publishSign) ) return false; if(! (l.meta == r.meta) ) return false;
if(! (l.idSign == r.idSign) ) return false;
if(l.transactionNumber != r.transactionNumber) return false; if(l.transactionNumber != r.transactionNumber) return false;
return true; return true;
@ -179,7 +141,7 @@ bool operator==(const RsNxsSyncMsg& l, const RsNxsSyncMsg& r)
bool operator==(const RsNxsSyncGrpItem& l, const RsNxsSyncGrpItem& r) bool operator==(const RsNxsSyncGrpItem& l, const RsNxsSyncGrpItem& r)
{ {
if(l.flag != r.flag) return false; if(l.flag != r.flag) return false;
if(! (l.adminSign == r.adminSign) ) return false; if(l.publishTs != r.publishTs) return false;
if(l.grpId != r.grpId) return false; if(l.grpId != r.grpId) return false;
if(l.transactionNumber != r.transactionNumber) return false; if(l.transactionNumber != r.transactionNumber) return false;

33
libretroshare/src/util/retrodb.cc
View file

@ -724,7 +724,8 @@ ContentValue::ContentValue(){
} }
ContentValue::~ContentValue(){ ContentValue::~ContentValue(){
// release resources held in data
clearData();
} }
ContentValue::ContentValue(ContentValue &from){ ContentValue::ContentValue(ContentValue &from){
@ -861,46 +862,51 @@ void ContentValue::put(const std::string &key, uint32_t len, const char* value){
bool ContentValue::getAsBool(const std::string &key, bool& value) const{ bool ContentValue::getAsBool(const std::string &key, bool& value) const{
if(mKvBool.find(key) == mKvBool.end()) std::map<std::string, bool>::const_iterator it;
if((it = mKvBool.find(key)) == mKvBool.end())
return false; return false;
value = mKvBool.at(key); value = it->second;
return true; return true;
} }
bool ContentValue::getAsInt32(const std::string &key, int32_t& value) const{ bool ContentValue::getAsInt32(const std::string &key, int32_t& value) const{
if(mKvInt32.find(key) == mKvInt32.end()) std::map<std::string, int32_t>::const_iterator it;
if((it = mKvInt32.find(key)) == mKvInt32.end())
return false; return false;
value = mKvInt32.at(key); value = it->second;
return true; return true;
} }
bool ContentValue::getAsInt64(const std::string &key, int64_t& value) const{ bool ContentValue::getAsInt64(const std::string &key, int64_t& value) const{
if(mKvInt64.find(key) == mKvInt64.end()) std::map<std::string, int64_t>::const_iterator it;
if((it = mKvInt64.find(key)) == mKvInt64.end())
return false; return false;
value = mKvInt64.at(key); value = it->second;
return true; return true;
} }
bool ContentValue::getAsString(const std::string &key, std::string &value) const{ bool ContentValue::getAsString(const std::string &key, std::string &value) const{
if(mKvString.find(key) == mKvString.end()) std::map<std::string, std::string>::const_iterator it;
if((it = mKvString.find(key)) == mKvString.end())
return false; return false;
value = mKvString.at(key); value = it->second;
return true; return true;
} }
bool ContentValue::getAsData(const std::string& key, uint32_t &len, char*& value) const{ bool ContentValue::getAsData(const std::string& key, uint32_t &len, char*& value) const{
if(mKvData.find(key) == mKvData.end()) std::map<std::string, std::pair<uint32_t, char*> >::const_iterator it;
if((it = mKvData.find(key)) == mKvData.end())
return false; return false;
const std::pair<uint32_t, char*> &kvRef = mKvData.at(key); const std::pair<uint32_t, char*> &kvRef = it->second;
len = kvRef.first; len = kvRef.first;
value = kvRef.second; value = kvRef.second;
@ -909,10 +915,11 @@ bool ContentValue::getAsData(const std::string& key, uint32_t &len, char*& value
bool ContentValue::getAsDouble(const std::string &key, double& value) const{ bool ContentValue::getAsDouble(const std::string &key, double& value) const{
if(mKvDouble.find(key) == mKvDouble.end()) std::map<std::string, double>::const_iterator it;
if((it = mKvDouble.find(key)) == mKvDouble.end())
return false; return false;
value = mKvDouble.at(key); value = it->second;
return true; return true;
} }