private void DeleteFilesFromFolder(object context)
{
DeleteFilesData data = (DeleteFilesData)context;
string folder = data.FolderInfo.FolderName;
DestinationOperationPerformer destinationOperationPerformer = data.DestinationOperationPerformer;
if (null != destinationOperationPerformer)
{
// Folder is at the destination. So we might need to impersonate.
destinationOperationPerformer(
this.DeleteFilesFromFolderWorker,
context);
}
else
{
// Folder is not at the destination. No need to impersonate.
this.DeleteFilesFromFolderWorker(context);
}
}
private void AddSubFoldersToQueue(object context)
{
SubFolderEnumerationData enumData = (SubFolderEnumerationData)context;
string folder = enumData.FolderInfo.FolderName;
DestinationOperationPerformer destinationOperationPerformer = enumData.DestinationOperationPerformer;
if (null != destinationOperationPerformer)
{
// Folder is at the destination. So we might need to impersonate.
destinationOperationPerformer(
this.AddSubFoldersToQueueWorker,
context);
}
else
{
// Folder is not at the destination. No need to impersonate.
this.AddSubFoldersToQueueWorker(context);
}
}
internal void DeleteOldFilesFromFolder(
string folder,
SetFolderDeletionInfoContext setContext,
IsOkToDeleteFile isOkToDelete,
DestinationOperationPerformer destinationOperationPerformer)
{
this.traceSource.WriteInfo(
this.logSourceId,
"Starting deletion of old files in directory {0} ...",
folder);
List <FolderDeletionInfo> folderList;
this.GetSubFoldersToDelete(folder, destinationOperationPerformer, setContext, out folderList);
this.DeleteFilesFromSubFolders(folder, destinationOperationPerformer, folderList, isOkToDelete);
this.traceSource.WriteInfo(
this.logSourceId,
"Finished deletion of old logs in directory {0}.",
folder);
}
private void DeleteFilesFromSubFolders(
string folder,
DestinationOperationPerformer destinationOperationPerformer,
List <FolderDeletionInfo> folderList,
IsOkToDeleteFile isOkToDelete)
{
// Figure out the timestamp before which all files will be deleted
DateTime cutoffTime = DateTime.UtcNow.Add(-this.fileDeletionAge);
foreach (FolderDeletionInfo folderInfo in folderList)
{
if (this.stopping)
{
this.traceSource.WriteInfo(
this.logSourceId,
"The consumer is being stopped. Therefore, no more files from folder {0} will be deleted.",
folder);
break;
}
DeleteFilesData deletionData = new DeleteFilesData();
deletionData.DestinationOperationPerformer = destinationOperationPerformer;
deletionData.FolderInfo = folderInfo;
deletionData.CutoffTime = cutoffTime;
deletionData.IsOkToDelete = isOkToDelete;
try
{
Utility.PerformIOWithRetries(
this.DeleteFilesFromFolder,
deletionData);
}
catch (Exception e)
{
this.traceSource.WriteExceptionAsError(
this.logSourceId,
e,
"Unable to enumerate files in folder {0} while attempting to delete old files.",
folderInfo.FolderName);
continue;
}
if (null != this.OnFolderEnumerated)
{
this.OnFolderEnumerated(this, EventArgs.Empty);
}
// We want to delete the directory if it is empty and if it is
// not the root directory.
if (false == folder.Equals(
folderInfo.FolderName,
StringComparison.OrdinalIgnoreCase))
{
// This is not the root directory. Try to delete it. If the
// directory is not empty, an IOException is thrown. We handle
// the exception and move on.
try
{
DirectoryDeletionInfo delInfo = new DirectoryDeletionInfo()
{
DirName = folderInfo.FolderName, CutoffTime = cutoffTime
};
if (null != destinationOperationPerformer)
{
// Folder is at the destination. So we might need to impersonate.
destinationOperationPerformer(
this.DeleteDirectoryAtDestination,
delInfo);
}
else
{
// Folder is not at the destination. No need to impersonate.
this.DeleteDirectoryIfOld(delInfo);
}
if (null != this.OnFolderDeleted)
{
this.OnFolderDeleted(this, EventArgs.Empty);
}
}
catch (Exception e)
{
if (false == ((e is FabricException) || (e is IOException)))
{
throw;
}
}
}
}
}
private void GetSubFoldersToDelete(
string folder,
DestinationOperationPerformer destinationOperationPerformer,
SetFolderDeletionInfoContext setContext,
out List <FolderDeletionInfo> folderList)
{
// Do a breadth-first traversal of the folder and make a list of all
// subfolders (including itself)
folderList = new List <FolderDeletionInfo>();
FolderDeletionInfo folderInfo = new FolderDeletionInfo();
folderInfo.FolderName = folder;
folderInfo.Context = null;
if (null != setContext)
{
setContext(folderInfo, null, null);
}
Queue <FolderDeletionInfo> folderQueue = new Queue <FolderDeletionInfo>();
folderQueue.Enqueue(folderInfo);
bool enumerationInterruptedDueToStop = false;
while (folderQueue.Count != 0)
{
if (this.stopping)
{
enumerationInterruptedDueToStop = true;
break;
}
folderInfo = folderQueue.Dequeue();
folderList.Add(folderInfo);
SubFolderEnumerationData enumData = new SubFolderEnumerationData();
enumData.DestinationOperationPerformer = destinationOperationPerformer;
enumData.FolderInfo = folderInfo;
enumData.FolderQueue = folderQueue;
enumData.SetContext = setContext;
try
{
Utility.PerformIOWithRetries(
this.AddSubFoldersToQueue,
enumData);
}
catch (Exception e)
{
this.traceSource.WriteExceptionAsError(
this.logSourceId,
e,
"Unable to enumerate subfolders of folder {0} while attempting to delete old files.",
folderInfo.FolderName);
}
}
if (enumerationInterruptedDueToStop)
{
this.traceSource.WriteInfo(
this.logSourceId,
"The consumer is being stopped. Therefore, enumeration of files to delete from folder {0} was interrupted.",
folder);
folderList.Clear();
return;
}
// Now we have a list of folders, top-down. However, we want to
// process the folders bottom-up, so that the folders themselves
// can be deleted if they become empty. So let's reverse the list.
folderList.Reverse();
}
