Added Cache's to retroshare configuration.

* Completed CacheConfig serialisation.
* Switched to Push Cache Mode (faster and more efficient).
* Added CancelCacheTransfer() if we have duplicate HASH / CACHEID.
* Store remote and local caches.
* cleanup all cache directories.
* Broke Cache tests :(  - because of dependency of mAuthMgr/mConnMgr.



git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@343 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
drbob 2008-02-09 12:47:45 +00:00
parent 1bb4283986
commit 276a6bbd99
21 changed files with 796 additions and 352 deletions

View file

@ -843,7 +843,7 @@ RsPeerStunItem *RsPeerConfigSerialiser::deserialiseStun(void *data, uint32_t *si
}
/****************************************************************************/
/****************************************************************************/
RsCacheConfig::~RsCacheConfig()
@ -851,43 +851,51 @@ RsCacheConfig::~RsCacheConfig()
return;
}
void RsCacheConfig::clear()
{
cacheid = 0;
path = "";
name = "";
hash = "";
recvd = 0;
}
std::ostream &RsCacheConfig::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsCacheConfig", indent); // begin 'WRITE' check
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent); //indent
out << "cacheid: " << cacheid << std::endl; // display value of cacheid
printIndent(out, int_Indent);
out << "path: " << path << std::endl; // display value of path
printIndent(out, int_Indent);
out << "name: " << name << std::endl; // display value of name
printIndent(out, int_Indent);
out << "hash: " << hash << std::endl; // display value of hash
printIndent(out, int_Indent);
out << "recvd: " << recvd << std::endl; // display value of recvd
printRsItemEnd(out, "RsCacheConfig", indent); // end of 'WRITE' check
return out;
}
/**************************************************************************/
void RsCacheConfig::clear()
{
pid.clear();
cachetypeid = 0;
cachesubid = 0;
path = "";
name = "";
hash = "";
size = 0;
recvd = 0;
}
std::ostream &RsCacheConfig::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsCacheConfig", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent); //indent
out << "pid: " << pid << std::endl; // display value of peerid
printIndent(out, int_Indent); //indent
out << "cacheid: " << cachetypeid << ":" << cachesubid << std::endl; // display value of cacheid
printIndent(out, int_Indent);
out << "path: " << path << std::endl; // display value of path
printIndent(out, int_Indent);
out << "name: " << name << std::endl; // display value of name
printIndent(out, int_Indent);
out << "hash: " << hash << std::endl; // display value of hash
printIndent(out, int_Indent);
out << "size: " << size << std::endl; // display value of size
printIndent(out, int_Indent);
out << "recvd: " << recvd << std::endl; // display value of recvd
printRsItemEnd(out, "RsCacheConfig", indent); // end of 'WRITE' check
return out;
}
/**************************************************************************/
RsCacheConfigSerialiser::~RsCacheConfigSerialiser()
{
@ -895,140 +903,148 @@ RsCacheConfigSerialiser::~RsCacheConfigSerialiser()
}
uint32_t RsCacheConfigSerialiser::size(RsItem *i)
{
{
RsCacheConfig *item = (RsCacheConfig *) i;
uint32_t s = 8; // to store calculated size, initiailize with size of header
s += 2; /* cacheid */
s += GetTlvStringSize(item->path);
s += GetTlvStringSize(item->name);
s += GetTlvStringSize(item->hash);
s += 2; /* recvd */
return s;
}
bool RsCacheConfigSerialiser::serialise(RsItem *i, void *data, uint32_t *size)
{
RsCacheConfig *item = (RsCacheConfig *) i;
uint32_t tlvsize = RsCacheConfigSerialiser::size(item);
uint32_t offset = 0;
if(*size < tlvsize)
return false; /* not enough space */
*size = tlvsize;
bool ok = true;
ok &=setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
std::cerr << "RsCacheConfigSerialiser::serialise() Header: " << ok << std::endl;
std::cerr << "RsCacheConfigSerialiser::serialise() Size: " << size << std::endl;
/* skip the header */
offset += 8;
/* add the mandatory parts first */
ok &= setRawUInt32(data, tlvsize, &offset, item->cacheid);
std::cerr << "RsCacheConfigSerialiser::serialise() cacheid: " << ok << std::endl;
ok &= setRawUInt32(data, tlvsize, &offset, item->recvd);
std::cerr << "RsCacheConfigSerialiser::serialise() recvd: " << ok << std::endl;
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PATH, item->path);
std::cerr << "RsCacheConfigSerialiser::serialise() path: " << ok << std::endl;
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->name);
std::cerr << "RsCacheConfigSerialiser::serialise() name: " << ok << std::endl;
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_HASH_SHA1, item->hash);
std::cerr << "RsCacheConfigSerialiser::serialise() hash: " << ok << std::endl;
if (offset !=tlvsize)
{
ok = false;
std::cerr << "RsConfigSerialiser::serialisertransfer() Size Error! " << std::endl;
}
return ok;
}
RsItem *RsCacheConfigSerialiser::deserialise(void *data, uint32_t *size)
{/* get the type and size */
uint32_t rstype = getRsItemId(data);
uint32_t rssize = getRsItemSize(data);
uint32_t *offset;
*offset = 0;
uint32_t tlvend = *offset + rssize;
if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) ||
(RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) ||
(RS_PKT_TYPE_CACHE_CONFIG != getRsItemType(rstype)) ||
(RS_PKT_SUBTYPE_DEFAULT != getRsItemSubType(rstype)))
{
return NULL; /* wrong type */
}
if (*size < rssize) /* check size */
return NULL; /* not enough data */
/* set the packet length */
*size = rssize;
bool ok = true;
/* ready to load */
RsCacheConfig *item = new RsCacheConfig();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= getRawUInt32(data, rssize, offset, &(item->cacheid));
std::cerr << "RsCacheConfigSerialiser::deserialise() cacheid: " << ok << std::endl;
ok &= getRawUInt32(data, rssize, offset, &(item->recvd));
std::cerr << "RsCacheConfigSerialiser::deserialise() recvd: " << ok << std::endl;
while((*offset) + 2 < tlvend)
{
/* get the next type */
uint16_t tlvsubtype = GetTlvType( &(((uint8_t *) data)[*offset]) );
switch(tlvsubtype)
{
case TLV_TYPE_STR_PATH:
ok &= GetTlvString(data, tlvend, offset, tlvsubtype, item->path);
break;
case TLV_TYPE_STR_NAME:
ok &= GetTlvString(data, tlvend, offset, tlvsubtype, item->name);
break;
case TLV_TYPE_STR_HASH_SHA1:
ok &= GetTlvString(data, tlvend, offset, tlvsubtype, item->hash);
break;
default:
break;
}
if (!ok)
{
return false;
}
uint32_t s = 8; // to store calculated size, initiailize with size of header
s += GetTlvStringSize(item->pid);
s += 2; /* cachetypeid */
s += 2; /* cachesubid */
s += GetTlvStringSize(item->path);
s += GetTlvStringSize(item->name);
s += GetTlvStringSize(item->hash);
s += 8; /* size */
s += 4; /* recvd */
return s;
}
bool RsCacheConfigSerialiser::serialise(RsItem *i, void *data, uint32_t *size)
{
RsCacheConfig *item = (RsCacheConfig *) i;
uint32_t tlvsize = RsCacheConfigSerialiser::size(item);
uint32_t offset = 0;
if(*size < tlvsize)
return false; /* not enough space */
*size = tlvsize;
bool ok = true;
ok &=setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
std::cerr << "RsCacheConfigSerialiser::serialise() Header: " << ok << std::endl;
std::cerr << "RsCacheConfigSerialiser::serialise() Size: " << size << std::endl;
/* skip the header */
offset += 8;
/* add the mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, item->pid);
std::cerr << "RsCacheConfigSerialiser::serialise() peerid: " << ok << std::endl;
ok &= setRawUInt16(data, tlvsize, &offset, item->cachetypeid);
std::cerr << "RsCacheConfigSerialiser::serialise() cacheTypeId: " << ok << std::endl;
ok &= setRawUInt16(data, tlvsize, &offset, item->cachesubid);
std::cerr << "RsCacheConfigSerialiser::serialise() cacheSubId: " << ok << std::endl;
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PATH, item->path);
std::cerr << "RsCacheConfigSerialiser::serialise() path: " << ok << std::endl;
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->name);
std::cerr << "RsCacheConfigSerialiser::serialise() name: " << ok << std::endl;
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_HASH_SHA1, item->hash);
std::cerr << "RsCacheConfigSerialiser::serialise() hash: " << ok << std::endl;
ok &= setRawUInt64(data, tlvsize, &offset, item->size);
std::cerr << "RsCacheConfigSerialiser::serialise() size: " << ok << std::endl;
ok &= setRawUInt32(data, tlvsize, &offset, item->recvd);
std::cerr << "RsCacheConfigSerialiser::serialise() recvd: " << ok << std::endl;
if (offset !=tlvsize)
{
ok = false;
std::cerr << "RsConfigSerialiser::serialisertransfer() Size Error! " << std::endl;
}
return ok;
}
RsItem *RsCacheConfigSerialiser::deserialise(void *data, uint32_t *size)
{/* get the type and size */
uint32_t rstype = getRsItemId(data);
uint32_t rssize = getRsItemSize(data);
uint32_t offset;
offset = 0;
if ((RS_PKT_VERSION1 != getRsItemVersion(rstype)) ||
(RS_PKT_CLASS_CONFIG != getRsItemClass(rstype)) ||
(RS_PKT_TYPE_CACHE_CONFIG != getRsItemType(rstype)) ||
(RS_PKT_SUBTYPE_DEFAULT != getRsItemSubType(rstype)))
{
return NULL; /* wrong type */
}
if (*size < rssize) /* check size */
return NULL; /* not enough data */
/* set the packet length */
*size = rssize;
bool ok = true;
/* ready to load */
RsCacheConfig *item = new RsCacheConfig();
item->clear();
/* skip the header */
offset += 8;
/* get mandatory parts first */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, item->pid);
std::cerr << "RsCacheConfigSerialiser::deserialise() peerid: " << ok << std::endl;
ok &= getRawUInt16(data, rssize, &offset, &(item->cachetypeid));
std::cerr << "RsCacheConfigSerialiser::serialise() cacheTypeId: " << ok << std::endl;
ok &= getRawUInt16(data, rssize, &offset, &(item->cachesubid));
std::cerr << "RsCacheConfigSerialiser::serialise() cacheSubId: " << ok << std::endl;
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PATH, item->path);
std::cerr << "RsCacheConfigSerialiser::serialise() path: " << ok << std::endl;
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_NAME, item->name);
std::cerr << "RsCacheConfigSerialiser::serialise() name: " << ok << std::endl;
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_HASH_SHA1, item->hash);
std::cerr << "RsCacheConfigSerialiser::deserialise() hash: " << ok << std::endl;
ok &= getRawUInt64(data, rssize, &offset, &(item->size));
std::cerr << "RsCacheConfigSerialiser::deserialise() size: " << ok << std::endl;
ok &= getRawUInt32(data, rssize, &offset, &(item->recvd));
std::cerr << "RsCacheConfigSerialiser::deserialise() recvd: " << ok << std::endl;
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
return item;
}