public void Remove()
{
if (Keep || !_componentDirectory.Exists)
{
return;
}
try
{
StaticViewModel.AddDebugMessage($"Removing {_componentDirectory.FullName}");
foreach (IFileInfo file in _componentDirectory.EnumerateFiles("*", SearchOption.AllDirectories))
{
if (file.IsReadOnly)
{
file.IsReadOnly = false;
}
}
_componentDirectory.Delete(true);
}
catch (Exception ex)
{
StaticViewModel.AddDebugMessage(ex, $"Unable to delete {_componentDirectory.FullName}");
}
}
/// <summary>
/// Gets the current start index for indexed DB's
/// </summary>
/// <param name="path">Main path to DB directory.</param>
/// <returns>Current - starting index of DB.</returns>
private int GetStartingIndex(string path)
{
// gets path to non-index DB.
string fullPath = _rocksDbFactory.GetFullDbPath(new RocksDbSettings(string.Empty, path));
IDirectoryInfo directory = _fileSystem.DirectoryInfo.FromDirectoryName(fullPath);
if (directory.Exists)
{
if (directory.EnumerateFiles().Any())
{
return(-2); // if there are files in the directory, then we have a main DB, marked -2.
}
// else we have sub-directories, which should be index based
// we want to find lowest positive index and return it - 1.
int minIndex = directory.EnumerateDirectories()
.Select(d => int.TryParse(d.Name, out int index) ? index : -1)
.Where(i => i >= 0)
.OrderBy(i => i)
.FirstOrDefault();
return(minIndex - 1);
}
return(-1); // if directory doesn't exist current index is -1.
}
/// <summary>
/// Returns all password files that match a search pattern.
/// </summary>
/// <param name="pattern">The pattern against which the files should be matched.</param>
public IEnumerable <PasswordFile> GetPasswordFiles(string pattern)
{
var patternRegex = new Regex(pattern);
var files = passwordStore.EnumerateFiles("*", SearchOption.AllDirectories);
var matchingFiles = files.Where(f => patternRegex.IsMatch(f.Name));
var passwordFiles = matchingFiles.Select(CreatePasswordFile);
return(passwordFiles);
}
private void ExtractArchivesInDir(IDirectoryInfo directory)
{
bool workDone = true;
while (workDone)
{
workDone = directory.EnumerateFiles("*", SearchOption.AllDirectories)
.Select(fi => archiveHandler.TryExtractAndDelete(fi))
.Any(extracted => extracted == true);
}
}
public override void SearchForDicomDirectories(string accessionsList)
{
Logger.Info("Starting accession directory path listing from: " + accessionsList);
IsProcessing = true;
TotalSent = 0;
using (StreamReader reader = FileSystem.File.OpenText(accessionsList))
{
while (!reader.EndOfStream && !TokenSource.IsCancellationRequested)
{
string accessionDirectory = reader.ReadLine().Replace(",", "");
if (!_accDirectoryRegex.IsMatch(accessionDirectory))
{
Logger.Warn($"This path does not point to an accession directory: ({accessionDirectory}), continuing");
continue;
}
if (!FileSystem.Directory.Exists(accessionDirectory))
{
Logger.Warn($"Can not find {accessionDirectory}, continuing");
continue;
}
IDirectoryInfo dirInfo = FileSystem.DirectoryInfo.FromDirectoryName(accessionDirectory);
IEnumerable <IFileInfo> fileEnumerator;
try
{
fileEnumerator = dirInfo.EnumerateFiles(SearchPattern);
}
catch (Exception e)
{
Logger.Error($"Could not enumerate files: {e.Message}");
continue;
}
if (fileEnumerator.FirstOrDefault() != null)
{
Logger.Debug("Sending message (" + accessionDirectory + ")");
FoundNewDicomDirectory(accessionDirectory.Remove(0, FileSystemRoot.Length));
}
else
{
Logger.Warn($"Could not find dicom files in the given accession directory ({accessionDirectory}), skipping");
}
}
}
IsProcessing = false;
Logger.Info("Reading from list finished");
Logger.Info("Total messages sent: " + TotalSent);
}
public void TraverseDirectory(string dn, string rw)
{
IDirectoryInfo dirInfo = this.fileSystem.DirectoryInfo.FromDirectoryName(dn);
foreach (IDirectoryInfo di in dirInfo.EnumerateDirectories())
{
Redactr r = new Redactr(this.fileSystem);
r.TraverseDirectory(di.FullName, rw);
}
foreach (IFileInfo fi in dirInfo.EnumerateFiles())
{
tasks.Add(Task.Factory.StartNew(() =>
{
Redactor.Redact(new RedactData(this.fileSystem, fi.FullName, rw, '*'));
}));
}
}
private IEnumerable <DisplayComponentModel> GetDisplayComponentFolders(string installerRoot)
{
IDirectoryInfo installerRootDirectory = _fileSystem.DirectoryInfo.FromDirectoryName(installerRoot);
if (!installerRootDirectory.Exists)
{
throw new DirectoryNotFoundException("Installer folder does not exist or cannot access.");
}
foreach (IFileInfo cccInstallFile in installerRootDirectory.EnumerateFiles("ccc2_install.exe", SearchOption.AllDirectories))
{
IDirectoryInfo displayDriverFolder = cccInstallFile.Directory.Parent;
foreach (IDirectoryInfo componentDirectory in displayDriverFolder.EnumerateDirectories("*", SearchOption.TopDirectoryOnly))
{
if (componentDirectory.GetFiles("*.inf", SearchOption.TopDirectoryOnly).Length == 1)
{
yield return(new DisplayComponentModel(installerRootDirectory, componentDirectory));
}
}
}
}
private IFileInfo FindCoredumpOrNull(IDirectoryInfo directory)
{
return(directory.EnumerateFiles("*.core", SearchOption.AllDirectories).FirstOrDefault());
}
/// <summary>
/// implementation of post-order traversal of directory tree
/// it is done this way to guarantee that by the time we finish any directory
/// all of its subdirectories/files had been visited
/// Note:
/// if operaiton is cancelled - not all notifications will be emited,
/// and namespace information will be partial.
/// </summary>
/// <param name="root">directory to scan</param>
/// <param name="cancelationCallback">function to consult with for cancelation</param>
/// <exception cref="System.IO.DirectoryNotFoundException">Cannot access directory: {root.FullName}</exception>
private void EnumeratePostOrderNonRecursive(IDirectoryInfo root, Func <bool> cancelationCallback = null)
{
// handle the case than this is actually network share.
if (!root.Exists())
{
throw new System.IO.DirectoryNotFoundException(string.Format(StorageSyncResources.NamespaceEnumeratorErrorFormat, root.FullName));
}
_namespaceInfo = new NamespaceInfo
{
Path = root.FullName,
IsComplete = false
};
Stack <IDirectoryInfo> stack1 = new Stack <IDirectoryInfo>(5000);
Stack <IDirectoryInfo> stack2 = new Stack <IDirectoryInfo>(5000);
Func <bool> shouldCancel = () =>
{
if (System.Diagnostics.Debugger.IsAttached)
{
return(false);
}
return(cancelationCallback == null ? false : cancelationCallback.Invoke());
};
stack1.Push(root);
_namespaceInfo.NumberOfDirectories++;
while (stack1.Count > 0)
{
if (shouldCancel())
{
return;
}
IDirectoryInfo currentDirectory = stack1.Pop();
stack2.Push(currentDirectory);
// notify we have started processing directory
// processing means accessing subdirectories and files
NotifyBeginDir(currentDirectory);
IList <IDirectoryInfo> subdirs = null;
try
{
subdirs = new List <IDirectoryInfo>(currentDirectory.EnumerateDirectories());
}
catch (UnauthorizedAccessException)
{
NotifyUnauthorizedDir(currentDirectory);
continue;
}
NotifyNamespaceHints(subdirs.Count, 0);
foreach (IDirectoryInfo subdir in subdirs)
{
stack1.Push(subdir);
_namespaceInfo.NumberOfDirectories++;
}
}
while (stack2.Count > 0)
{
if (shouldCancel())
{
return;
}
IDirectoryInfo currentDirectory = stack2.Pop();
IList <IFileInfo> files = new List <IFileInfo>(currentDirectory.EnumerateFiles());
NotifyNamespaceHints(0, files.Count);
foreach (IFileInfo file in files)
{
_namespaceInfo.NumberOfFiles++;
_namespaceInfo.TotalFileSizeInBytes += file.Length;
NotifyNextFile(file);
}
// notify we have finished processing directory
NotifyEndDir(currentDirectory);
}
_namespaceInfo.IsComplete = true;
}
protected virtual IEnumerable <IFileInfo> GetEnumerator(IDirectoryInfo dirInfo)
{
return(dirInfo.EnumerateFiles(SearchPattern));
}
/// <summary>
/// Checks whether the directory contains the given file.
/// </summary>
/// <returns>True if the directory contains the file, false otherwise.</returns>
internal static bool ContainsFile(this IDirectoryInfo directory, string name)
{
return(directory.EnumerateFiles(name).Any());
}
protected override IEnumerable <IFileInfo> GetEnumerator(IDirectoryInfo dirInfo)
{
return(dirInfo.EnumerateFiles().Where(f => f.Extension == ".dcm" || ZipHelper.IsZip(f)));
}
