/* Fetch and unpack the archive 'arcHash' into the directory
'path'. If path="", then just index the archive.
*/
void DirInstaller::unpackBlind(const Hash &arcHash, const std::string &path)
{
TreePtr job = owner.unpackBlindTarget(path);
job->addInput(arcHash);
job->finder = finder;
if(path != "")
log(" Blind unpacking " + arcHash.toString() + " => " + path);
else
log(" Blind indexing " + arcHash.toString());
execJob(job);
}
void DirInstaller::loadHint(const Hash &hint)
{
log("Loading HINT=" + hint.toString());
// Check if there is an archive associated with the given hash
const ArcRuleData *arc = ptr->origRules->findArchive(hint);
// If there is no archive rule, then ignore this hint.
if(!arc)
{
log(" No hint archive found, skipping.");
return;
}
log(" Found archive rule: dir=" + arc->dirHash.toString() +
" arc=" + arc->arcHash.toString());
DirMap tmp;
DirPtr arcDir;
try { arcDir = addDirFile(tmp, arc->dirHash, ""); }
catch(...)
{
// Blind-index archive, then try again
unpackBlind(arc->arcHash, "");
// This time, allow the exception to fall through on failure
arcDir = addDirFile(tmp, arc->dirHash, "");
}
// Add archive to the ArcRuleSet.
ptr->arcRules->addArchive(arc->arcHash, arc->dirHash, arcDir,
arc->ruleString);
}
void TrustTreeModel::contentReceived(const Hash& aHashOfContent,
const ProtocolItemType aTypeOfReceivdContent) {
if ( aTypeOfReceivdContent == UserProfile ) {
QLOG_STR("TrustTreeModel::contentReceived(), profile=" + aHashOfContent.toString() ) ;
iController.model().lock() ;
TrustTreeItem operatorFromTrustList ( (*iTrustTree)[aHashOfContent] ) ;
if ( operatorFromTrustList.iTrustingOperator != KNullHash ) {
// ok, operator was in trust list.
operatorFromTrustList.iNeedsUpdate = true ;
recalculateTrust() ;
}
iController.model().unlock() ;
}
}
/* Check the rule system if there are any hints associated with a
given dirHash, then load them.
*/
void DirInstaller::loadDirHints(const Hash &dirHash)
{
const std::vector<Hash> *hints = ptr->arcRules->findHints(dirHash);
if(!hints || hints->size() == 0)
return;
log("Found rule hints for dirHash=" + dirHash.toString());
for(int i=0; i<hints->size(); i++)
{
const Hash &hint = (*hints)[i];
loadHint(hint);
}
}
/* Load the directory object 'dirHash' and store results in
'out'. Fetches the dirfile if necessary, and takes care of dir
cache bookkeeping. Returns a DirPtr to the loaded dir.
The 'path' parameter only affects the filenames added to the 'out'
list. It does not affect the returned DirPtr.
*/
DirPtr DirInstaller::addDirFile(DirMap &out, const Hash &dirHash,
const std::string &path)
{
// Load any hints associated with the dir first
loadDirHints(dirHash);
// Fetch the dir file if possible
std::string dirFile = fetchFile(dirHash);
// Load and use it
DirPtr dir(new DirMap);
owner.loadDir(dirFile, *dir, dirHash);
Dir::add(out, *dir, path);
log("Loaded DIR dirHash=" + dirHash.toString());
return dir;
}
void DirInstaller::handleHash(DirMap &out, const Hash &dirHash,
HashDir &blinds, const std::string &path)
{
// Check if there is an archive associated with the given hash
const ArcRuleData *arc = ptr->origRules->findArchive(dirHash);
if(!arc)
{
log("Hash " + dirHash.toString() + " does NOT match any archive rule, assuming dirHash");
/* Just load the dir and add it to 'out', along with any hints
associated with it. We assume this is enough to find all the
files we need. Throws on error.
*/
addDirFile(out, dirHash, path);
return;
}
/* We found an archive. Try loading the dirfile and injecting it
into the ArcRuleSet. This will make the contained files directly
available through the rule system, where the fetchFiles() system
can find them. This is the preferred solution.
*/
log("FOUND archive rule: dir=" + arc->dirHash.toString() +
" arc=" + arc->arcHash.toString());
try
{
DirPtr arcDir = addDirFile(out, arc->dirHash, path);
ptr->arcRules->addArchive(arc->arcHash, arc->dirHash, arcDir,
arc->ruleString);
}
catch(std::exception &e)
{
/* If the dirfile loading fails for whatever reason (perhaps the
dirfile is not available anywhere), then fall back to doing a
"blind" unpack.
*/
log("FAILED loading dirHash=" + arc->dirHash.toString() +
"\n Error message: " + std::string(e.what()) +
"\n Reverting to blind unpack");
blinds.insert(HDValue(arc->arcHash, path));
}
}