BBSNode::BBSNode(BackupStoreDirectory::Entry entry, int64_t myparentid){
qDebug() << "BBSNode::BBSNode:Begin";
BackupStoreFilenameClear clear(entry.GetName());
id = entry.GetObjectID();
name = clear.GetClearFilename();
size = entry.GetSizeInBlocks();
parentid = myparentid;
modtime = BoxTimeToSeconds(entry.GetModificationTime());
type = NT_LOCATION;
if ((entry.GetFlags() & BackupStoreDirectory::Entry::Flags_Dir)!=0) type = NT_DIR;
if ((entry.GetFlags() & BackupStoreDirectory::Entry::Flags_File)!=0) type = NT_FILE;
if (parentid == -1)
{
type = NT_ROOT;
}
qDebug() << type;
}
// --------------------------------------------------------------------------
//
// Function
// Name: HousekeepStoreAccount::ScanDirectory(int64_t)
// Purpose: Private. Scan a directory for potentially deleteable
// items, and add them to the list. Returns true if the
// scan should continue.
// Created: 11/12/03
//
// --------------------------------------------------------------------------
bool HousekeepStoreAccount::ScanDirectory(int64_t ObjectID,
BackupStoreInfo& rBackupStoreInfo)
{
#ifndef WIN32
if((--mCountUntilNextInterprocessMsgCheck) <= 0)
{
mCountUntilNextInterprocessMsgCheck =
POLL_INTERPROCESS_MSG_CHECK_FREQUENCY;
// Check for having to stop
// Include account ID here as the specified account is locked
if(mpHousekeepingCallback && mpHousekeepingCallback->CheckForInterProcessMsg(mAccountID))
{
// Need to abort now
return false;
}
}
#endif
// Get the filename
std::string objectFilename;
MakeObjectFilename(ObjectID, objectFilename);
// Open it.
std::auto_ptr<RaidFileRead> dirStream(RaidFileRead::Open(mStoreDiscSet,
objectFilename));
// Add the size of the directory on disc to the size being calculated
int64_t originalDirSizeInBlocks = dirStream->GetDiscUsageInBlocks();
mBlocksInDirectories += originalDirSizeInBlocks;
mBlocksUsed += originalDirSizeInBlocks;
// Read the directory in
BackupStoreDirectory dir;
BufferedStream buf(*dirStream);
dir.ReadFromStream(buf, IOStream::TimeOutInfinite);
dir.SetUserInfo1_SizeInBlocks(originalDirSizeInBlocks);
dirStream->Close();
// Is it empty?
if(dir.GetNumberOfEntries() == 0)
{
// Add it to the list of directories to potentially delete
mEmptyDirectories.push_back(dir.GetObjectID());
}
// Calculate reference counts first, before we start requesting
// files to be deleted.
// BLOCK
{
BackupStoreDirectory::Iterator i(dir);
BackupStoreDirectory::Entry *en = 0;
while((en = i.Next()) != 0)
{
// This directory references this object
mapNewRefs->AddReference(en->GetObjectID());
}
}
// BLOCK
{
// Remove any files which are marked for removal as soon
// as they become old or deleted.
bool deletedSomething = false;
do
{
// Iterate through the directory
deletedSomething = false;
BackupStoreDirectory::Iterator i(dir);
BackupStoreDirectory::Entry *en = 0;
while((en = i.Next(BackupStoreDirectory::Entry::Flags_File)) != 0)
{
int16_t enFlags = en->GetFlags();
if((enFlags & BackupStoreDirectory::Entry::Flags_RemoveASAP) != 0
&& (en->IsDeleted() || en->IsOld()))
{
// Delete this immediately.
DeleteFile(ObjectID, en->GetObjectID(), dir,
objectFilename, rBackupStoreInfo);
// flag as having done something
deletedSomething = true;
// Must start the loop from the beginning again, as iterator is now
// probably invalid.
break;
}
}
} while(deletedSomething);
}
// BLOCK
{
// Add files to the list of potential deletions
// map to count the distance from the mark
typedef std::pair<std::string, int32_t> version_t;
std::map<version_t, int32_t> markVersionAges;
// map of pair (filename, mark number) -> version age
// NOTE: use a reverse iterator to allow the distance from mark stuff to work
BackupStoreDirectory::ReverseIterator i(dir);
BackupStoreDirectory::Entry *en = 0;
while((en = i.Next(BackupStoreDirectory::Entry::Flags_File)) != 0)
{
// Update recalculated usage sizes
int16_t enFlags = en->GetFlags();
int64_t enSizeInBlocks = en->GetSizeInBlocks();
mBlocksUsed += enSizeInBlocks;
if(en->IsOld()) mBlocksInOldFiles += enSizeInBlocks;
if(en->IsDeleted()) mBlocksInDeletedFiles += enSizeInBlocks;
// Work out ages of this version from the last mark
int32_t enVersionAge = 0;
std::map<version_t, int32_t>::iterator enVersionAgeI(
markVersionAges.find(
version_t(en->GetName().GetEncodedFilename(),
en->GetMarkNumber())));
if(enVersionAgeI != markVersionAges.end())
{
enVersionAge = enVersionAgeI->second + 1;
enVersionAgeI->second = enVersionAge;
}
else
{
markVersionAges[version_t(en->GetName().GetEncodedFilename(), en->GetMarkNumber())] = enVersionAge;
}
// enVersionAge is now the age of this version.
// Potentially add it to the list if it's deleted, if it's an old version or deleted
if(en->IsOld() || en->IsDeleted())
{
// Is deleted / old version.
DelEn d;
d.mObjectID = en->GetObjectID();
d.mInDirectory = ObjectID;
d.mSizeInBlocks = en->GetSizeInBlocks();
d.mMarkNumber = en->GetMarkNumber();
d.mVersionAgeWithinMark = enVersionAge;
d.mIsFlagDeleted = en->IsDeleted();
// Add it to the list
mPotentialDeletions.insert(d);
// Update various counts
mPotentialDeletionsTotalSize += d.mSizeInBlocks;
if(d.mSizeInBlocks > mMaxSizeInPotentialDeletions) mMaxSizeInPotentialDeletions = d.mSizeInBlocks;
// Too much in the list of potential deletions?
// (check against the deletion target + the max size in deletions, so that we never delete things
// and take the total size below the deletion size target)
if(mPotentialDeletionsTotalSize > (mDeletionSizeTarget + mMaxSizeInPotentialDeletions))
{
int64_t sizeToRemove = mPotentialDeletionsTotalSize - (mDeletionSizeTarget + mMaxSizeInPotentialDeletions);
bool recalcMaxSize = false;
while(sizeToRemove > 0)
{
// Make iterator for the last element, while checking that there's something there in the first place.
std::set<DelEn, DelEnCompare>::iterator i(mPotentialDeletions.end());
if(i != mPotentialDeletions.begin())
{
// Nothing left in set
break;
}
// Make this into an iterator pointing to the last element in the set
--i;
// Delete this one?
if(sizeToRemove > i->mSizeInBlocks)
{
sizeToRemove -= i->mSizeInBlocks;
if(i->mSizeInBlocks >= mMaxSizeInPotentialDeletions)
{
// Will need to recalculate the maximum size now, because we've just deleted that element
recalcMaxSize = true;
}
mPotentialDeletions.erase(i);
}
else
{
// Over the size to remove, so stop now
break;
}
}
if(recalcMaxSize)
{
// Because an object which was the maximum size recorded was deleted from the set
// it's necessary to recalculate this maximum.
mMaxSizeInPotentialDeletions = 0;
std::set<DelEn, DelEnCompare>::const_iterator i(mPotentialDeletions.begin());
for(; i != mPotentialDeletions.end(); ++i)
{
if(i->mSizeInBlocks > mMaxSizeInPotentialDeletions)
{
mMaxSizeInPotentialDeletions = i->mSizeInBlocks;
}
}
}
}
}
}
}
// Recurse into subdirectories
{
BackupStoreDirectory::Iterator i(dir);
BackupStoreDirectory::Entry *en = 0;
while((en = i.Next(BackupStoreDirectory::Entry::Flags_Dir)) != 0)
{
ASSERT(en->IsDir());
if(!ScanDirectory(en->GetObjectID(), rBackupStoreInfo))
{
// Halting operation
return false;
}
}
}
return true;
}