public void GetDirectoriesFor2()
{
string folder1 = "folder1";
string folder2 = "folder2";
this.testFolder.CreateSubdirectory(folder1);
this.testFolder.CreateSubdirectory(folder2);
IDirectoryInfo dirInfo = Factory.CreateDirectoryInfo(this.testFolder.FullName);
Assert.That(dirInfo.GetDirectories().Length, Is.EqualTo(2));
Assert.That(dirInfo.GetDirectories()[0].Name, Is.EqualTo(folder1));
Assert.That(dirInfo.GetDirectories()[1].Name, Is.EqualTo(folder2));
}
public IDirectoryInfo GetDirectoryInfo(string path)
{
var parts = path.Split('\\');
IDirectoryInfo dir = null;
foreach (var part in parts)
{
if (dir == null)
{
if (string.Equals(part, "sdata:", StringComparison.OrdinalIgnoreCase))
{
dir = _directory;
}
}
else
{
dir = dir.GetDirectories().FirstOrDefault(item => string.Equals(part, item.Name, StringComparison.OrdinalIgnoreCase));
}
if (dir == null)
{
throw new NotSupportedException();
}
}
if (dir == null)
{
throw new NotSupportedException();
}
return(dir);
}
public override Microsoft.Extensions.FileSystemGlobbing.Abstractions.DirectoryInfoBase GetDirectory(string path)
{
bool isParentPath = string.Equals(path, "..", StringComparison.Ordinal);
if (isParentPath)
{
return(new DirectoryInfoBaseAbstractionAdapter(
directory.FileSystem.DirectoryInfo.FromDirectoryName(directory.FileSystem.Path.Combine(directory.FullName, path)),
isParentPath));
}
else
{
IDirectoryInfo[] dirs = directory.GetDirectories(path);
if (dirs.Length == 1)
{
return(new DirectoryInfoBaseAbstractionAdapter(dirs[0], isParentPath));
}
else if (dirs.Length == 0)
{
return(null);
}
else
{
// This shouldn't happen. The parameter path isn't supposed to contain wild card.
throw new InvalidOperationException(
string.Format("More than one sub directories are found under {0} with path {1}.",
directory.FullName, path));
}
}
}
private async Task AddDirectoryFilesToTar(TarOutputStream tarArchive, IDirectoryInfo directory)
{
if (!string.IsNullOrWhiteSpace(GetRelativePath(directory)))
{
var tarEntry = TarEntry.CreateEntryFromFile(directory.FullName);
tarEntry.Name = GetRelativePath(directory);
tarArchive.PutNextEntry(tarEntry);
}
// Write each file to the tar.
foreach (var file in directory.GetFiles())
{
var tarEntry = TarEntry.CreateEntryFromFile(file.FullName);
tarEntry.Name = GetRelativePath(file);
tarEntry.Size = file.Length;
tarArchive.PutNextEntry(tarEntry);
using var fileStream = file.OpenRead();
await fileStream.CopyToAsync(tarArchive);
tarArchive.CloseEntry();
}
foreach (var childDirectory in directory.GetDirectories())
{
await AddDirectoryFilesToTar(tarArchive, childDirectory);
}
}
private static IDirectoryInfo CopyDirectory(IDirectoryInfo source, IDirectoryInfo destination)
{
var targetDir = destination.GetDirectories().FirstOrDefault(dir => string.Equals(dir.Name, source.Name, StringComparison.OrdinalIgnoreCase))
?? destination.CreateSubdirectory(source.Name);
foreach (var sourceFile in source.GetFiles())
{
var name = sourceFile.Name;
var targetFile = targetDir.GetFiles().FirstOrDefault(item => string.Equals(item.Name, name, StringComparison.OrdinalIgnoreCase))
?? destination.DriveInfo.GetFileInfo(Path.Combine(targetDir.FullName, name));
using (var input = sourceFile.Open(FileMode.Open, FileAccess.Read))
using (var output = targetFile.Open(FileMode.OpenOrCreate, FileAccess.Write))
{
input.CopyTo(output);
}
}
foreach (var subSource in source.GetDirectories())
{
CopyDirectory(subSource, targetDir);
}
return(targetDir);
}
private static IDirectoryInfo CopyDirectory(IDirectoryInfo source, IDirectoryInfo destination)
{
var targetDir = destination.GetDirectories().FirstOrDefault(dir => string.Equals(dir.Name, source.Name, StringComparison.OrdinalIgnoreCase))
?? destination.CreateSubdirectory(source.Name);
foreach (var sourceFile in source.GetFiles())
{
var name = sourceFile.Name;
var targetFile = targetDir.GetFiles().FirstOrDefault(item => string.Equals(item.Name, name, StringComparison.OrdinalIgnoreCase))
?? destination.DriveInfo.GetFileInfo(Path.Combine(targetDir.FullName, name));
using (var input = sourceFile.Open(FileMode.Open, FileAccess.Read))
using (var output = targetFile.Open(FileMode.OpenOrCreate, FileAccess.Write))
{
input.CopyTo(output);
}
}
foreach (var subSource in source.GetDirectories())
{
CopyDirectory(subSource, targetDir);
}
return targetDir;
}
/// <summary>
/// Creates a test directory with the specified name under the TV directory.
/// </summary>
/// <param name="parent">
/// The parent directory.
/// </param>
/// <param name="names">
/// The names of the directories to create.
/// </param>
/// <returns>
/// The directory info.
/// </returns>
protected IDirectoryInfo[] CreateTestDirectory(IDirectoryInfo parent, params string[] names)
{
var directories = new IDirectoryInfo[names.Length];
for (var i = 0; i < names.Length; i++)
{
var directory = Substitute.For <IDirectoryInfo>();
directory.Name.Returns(names[i]);
var fullName = names[i];
if (parent != null)
{
fullName = parent.FullName + Path.DirectorySeparatorChar + names[i];
}
directory.FullName.Returns(fullName);
directory.Exists.Returns(true);
directories[i] = directory;
}
if (parent != null)
{
parent.GetDirectories().Returns(directories);
}
return(directories);
}
public static List <IDirectoryInfo> GetAllDirs(IDirectoryInfo dir, List <IDirectoryInfo> dirs = null)
{
if (dirs == null)
{
dirs = new List <IDirectoryInfo>();
}
try
{
dirs.Add(dir);
foreach (var d in dir.GetDirectories())
{
GetAllDirs(d, dirs);
}
}
catch (UnauthorizedAccessException ex)
{
}
catch (Exception ex)
{
//generate error
}
return(dirs);
}
private void CopySubDirectories(IDirectoryInfo sourceDirectory, IDirectoryInfo destinationDirectory)
{
IDirectoryInfo[] subDirectories = sourceDirectory.GetDirectories();
foreach (IDirectoryInfo subDirectory in subDirectories)
{
IDirectoryInfo destSubDirectory = destinationDirectory.CreateSubdirectory(subDirectory.Name);
CopyDirectory(subDirectory, destSubDirectory);
}
}
public FolderTree(IDirectoryInfo dir, string name = null)
{
this.Name = name ?? dir.Name;
this.IsFile = false;
this.LocalId = dir.Uuid == null ? null : dir.Uuid.GetValueOrDefault().ToString();
foreach (var child in dir.GetDirectories())
{
this.children.Add(new FolderTree(child));
}
this.children.Sort((FolderTree x, FolderTree y) => x.Name.CompareTo(y.Name));
}
private static void SetNormalAttribute(IDirectoryInfo dirInfo)
{
foreach (var subDir in dirInfo.GetDirectories())
{
SetNormalAttribute(subDir);
}
foreach (var file in dirInfo.GetFiles())
{
file.Attributes = FileAttributes.Normal;
}
}
private void CopyFiles(IDirectoryInfo source, IDirectoryInfo target)
{
foreach (var fi in source.GetFiles())
{
fi.CopyTo(this.fileSystem.Path.Combine(target.FullName, fi.Name));
}
foreach (var subDirectory in source.GetDirectories())
{
var nextTargetSubDir = target.CreateSubdirectory(subDirectory.Name);
this.CopyFiles(subDirectory, nextTargetSubDir);
}
}
private void CopyDirectoryHelper(IDirectoryInfo source, IDirectoryInfo target)
{
// Check if the target directory exists, if not, create it.
if (!target.Exists)
{
try
{
Directory.CreateDirectory(target.FullName);
}
catch (Exception ex)
{
throw new Exception(string.Format("Failed to create directory: {0}.", target.FullName), ex);
}
}
// Copy each file into its new directory.
IFileInfo[] files = source.GetFiles();
foreach (IFileInfo file in files)
{
// Check if operation was cancelled
CheckStopped();
CopyFile(file, new FileInfoWrapper(Path.Combine(target.FullName, file.Name)));
}
// Copy each subdirectory using recursion.
IDirectoryInfo[] subdirectories = source.GetDirectories();
foreach (IDirectoryInfo sourceSubdirectory in subdirectories)
{
// Check if operation was cancelled
CheckStopped();
IDirectoryInfo targetSubdirectory =
new DirectoryInfoWrapper(Path.Combine(target.FullName, sourceSubdirectory.Name));
if (!targetSubdirectory.Exists)
{
try
{
targetSubdirectory.Create();
}
catch (Exception ex)
{
throw new Exception(
string.Format("Failed to create directory: {0}.", targetSubdirectory.FullName), ex);
}
}
CopyDirectoryHelper(sourceSubdirectory, targetSubdirectory);
}
target.Attributes = source.Attributes;
target.LastWriteTime = source.LastWriteTime;
}
internal static long GetDirectorySize(IDirectoryInfo d)
{
long ret = 0;
foreach (var item in d.GetDirectories())
{
ret += GetDirectorySize(item);
}
foreach (var item in d.GetFiles())
{
ret += item.Length;
}
return(ret);
}
private IDirectoryInfo GetDirectoryPath(IDirectoryInfo directoryPath, string subDirectory)
{
if (string.IsNullOrEmpty(subDirectory))
{
return(directoryPath);
}
var target = directoryPath.GetDirectories(subDirectory, SearchOption.TopDirectoryOnly).FirstOrDefault();
if (target == null || !target.Exists)
{
target = directoryPath.CreateSubdirectory(subDirectory);
}
return(target);
}
/// <summary>
/// remove a folder if there are no files in it, used by the synchroniser
/// </summary>
/// <param name="folder">folder to delete</param>
/// <param name="whatIf">true to emit all the status updates but not actually perform the deletes, false to do the delete</param>
public void RemoveFolderIfEmpty(string folder, bool whatIf)
{
IDirectoryInfo directoryInfo = _directoryInfoProvider.GetDirectoryInfo(folder);
if (!directoryInfo.Exists)
{
return;
}
IDirectoryInfo[] subFolders;
try
{
subFolders = directoryInfo.GetDirectories("*.*");
}
catch (DirectoryNotFoundException)
{
// if the folder is not there then there is nothing to do
return;
}
if (subFolders != null && subFolders.Length > 0)
{
// the folder is not empty - there are subfolders
return;
}
IFileInfo[] files;
try
{
files = directoryInfo.GetFiles("*.*");
}
catch (DirectoryNotFoundException)
{
// if the folder is not there then there is nothing to do
return;
}
if (files != null && files.Length > 0)
{
// the folder is not empty there are files
return;
}
OnStatusUpdate(string.Format(CultureInfo.InvariantCulture, "Removing folder: {0}", directoryInfo.FullName));
if (!whatIf)
{
directoryInfo.Delete();
}
}
// ******************************************************************************
/// <summary>
/// Returns a fully populate heirarchy for this forlder
/// </summary>
/// <param name="directoryInfo">Object representing the root folder to scan</param>
/// <returns>Populated Heirarchy</returns>
// ******************************************************************************
CosmosDirItem ScanFolder(IDirectoryInfo directoryInfo, CancellationToken cancelToken)
{
CurrentItemLabel = directoryInfo.FullName;
CosmosDirectoryInfo cosmosDirectoryInfo = (CosmosDirectoryInfo)directoryInfo;
CosmosDirItem thisDir = new CosmosDirItem(directoryInfo.Name, directoryInfo.FullName);
//thisDir.TotalValue = Math.Max(0, cosmosDirectoryInfo.CosmosSize);
if (cancelToken.IsCancellationRequested)
{
return(thisDir);
}
double totalFolderSize = 0;
try
{
// Total up the size of the content
foreach (var file in directoryInfo.GetFiles())
{
thisDir.AddContent(file.Name, file);
var fileSize = Math.Max(0, file.GetValue(CosmosDirectoryInfo.STREAMSIZE));
UnitsScannedSoFar += fileSize;
totalFolderSize += fileSize;
file.SetValue(CosmosDirectoryInfo.STREAMSIZE, fileSize);
if (cancelToken.IsCancellationRequested)
{
return(thisDir);
}
}
// recurse into the child directories
foreach (IDirectoryInfo dir in directoryInfo.GetDirectories())
{
CosmosDirItem newDir = ScanFolder(dir, cancelToken);
thisDir.AddChild(newDir);
}
}
catch (UnauthorizedAccessException) { } // Ignore permissions problems
catch (Exception e)
{
#if DEBUG
Debugger.Break();
#endif
Debug.WriteLine("Error: " + e.Message);
}
//thisDir.TotalValue = totalFolderSize;
return(thisDir);
}
private void CopyAll(IDirectoryInfo source, IDirectoryInfo destination)
{
// copy each file into destination
foreach (var file in source.GetFiles())
{
file.CopyTo(_fileSystem.Path.Combine(destination.FullName, file.Name), true);
}
// copy each subdirectory using recursion
foreach (var diSourceSubDir in source.GetDirectories())
{
var nextTargetSubDir = destination.CreateSubdirectory(diSourceSubDir.Name);
CopyAll(diSourceSubDir, nextTargetSubDir);
}
}
public void Init(IDirectoryInfo d)
{
if (StartDirectory == null)
{
StartDirectory = d;
}
Sectors.Clear();
Text = "Memory report: " + d.FullName;
CurrentDirectory = d;
var list = Stuff.GetAllFiles(d);
var total = list.Sum(z => z.Length);
TotalLen = total;
var rootl = d.GetFiles().Sum(z => z.Length);
if (rootl > 0)
{
Sectors.Add(new ReportSectorInfo()
{
Name = ".root", Length = rootl, Tag = d, Percentage = (float)rootl / total
});
}
foreach (var item in d.GetDirectories())
{
var f = Stuff.GetAllFiles(item);
var l = f.Sum(z => z.Length);
Sectors.Add(new ReportSectorInfo()
{
Name = item.Name,
Length = l,
Percentage = (float)l / total,
Tag = item
});
}
Sectors = Sectors.OrderByDescending(z => z.Percentage).ToList();
listView1.Items.Clear();
foreach (var item in Sectors)
{
listView1.Items.Add(new ListViewItem(new string[] { item.Name, Stuff.GetUserFriendlyFileSize(item.Length), (item.Percentage * 100).ToString("F") + "%" })
{
Tag = item
});
}
//listView1.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
//listView1.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
}
/// <exception cref="FileEntityNotFoundException">Ошибка при получении списка папок</exception>
public override List <FileSystemEntity> GetDirectories()
{
IDirectoryInfo[] directories;
try {
directories = info.GetDirectories();
} catch (DirectoryNotFoundException e) {
throw new FileEntityNotFoundException("Ошибка при получении списка папок.", e);
}
var result = new List <FileSystemEntity>();
for (var i = 0; i < directories.Length; ++i)
{
result.Add(new DirectoryEntity(directories[i]));
}
return(result);
}
/// <summary>
/// Gets the directory info at the specified path.
/// </summary>
/// <param name="path">The path of the directory.</param>
/// <returns>
/// An <see cref="IDirectoryInfo"/> of the directory from the specified path.
/// </returns>
public IDirectoryInfo GetDirectoryInfo(string path)
{
path.ThrowIfNull(() => path);
if (!this.DirectoryExists(path))
{
return(ITunesDirectoryInfo
.CreateNonExistantDirectoryInfo(Path.GetFileName(path), (ITunesDirectoryInfo)this.GetDirectoryInfo(Path.GetDirectoryName(path))));
}
string[] split = path.Split(Path.DirectorySeparatorChar);
string playlist = split[0];
string album = null;
if (split.Length > 1)
{
string artist = split[1];
if (split.Length > 2)
{
album = split[2];
}
var root = this.GetPlaylistStructure(playlist);
IDirectoryInfo directoryInfo = root
.SingleOrDefault(dir => dir.Name == artist);
if (directoryInfo == null)
{
directoryInfo = ITunesDirectoryInfo
.CreateNonExistantDirectoryInfo(album ?? artist, (ITunesDirectoryInfo)this.GetDirectoryInfo(Path.GetDirectoryName(path)));
}
else if (album != null)
{
directoryInfo = directoryInfo
.GetDirectories()
.Single(albumDir => albumDir.Name == album);
}
return(directoryInfo);
}
return(new ITunesDirectoryInfo(playlist));
}
private void When_getting_directories_it_must_succeed()
{
// Arrange
const string path = @"c:\some\folder";
IFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingDirectory(@"c:\some\folder\sub")
.Build();
IDirectoryInfo dirInfo = fileSystem.ConstructDirectoryInfo(path);
// Act
IDirectoryInfo[] infos = dirInfo.GetDirectories();
// Assert
infos.Should().ContainSingle(x => x.FullName == @"c:\some\folder\sub");
}
/// <summary>
/// Searches for a directory containing a ".git" directory
/// up from the current one.
/// </summary>
private IDirectoryInfo TryFindGitRepositoryDirectory(string source)
{
IDirectoryInfo di = _fileSystem.DirectoryInfo.Create(source);
do
{
bool containsGitFolder = di.GetDirectories(".git", SearchOption.TopDirectoryOnly).Any();
if (containsGitFolder)
{
break;
}
di = di.Parent;
} while (di != null);
return(di);
}
private void SetDirectory(IDirectoryInfo directoryInfo)
{
if (Ignore(directoryInfo))
{
return;
}
SetFileSystem(directoryInfo);
SetFileSystem(directoryInfo.GetFileSystemInfos());
if (!IsRecurse)
{
return;
}
SetDirectory(directoryInfo.GetDirectories());
}
/// <summary>
/// Gets the local directory tree.
/// </summary>
/// <returns>The local directory tree.</returns>
/// <param name="parent">Parent directory.</param>
/// <param name="filter">Filter for files.</param>
public static IObjectTree <IFileSystemInfo> GetLocalDirectoryTree(IDirectoryInfo parent, IFilterAggregator filter)
{
var children = new List <IObjectTree <IFileSystemInfo> >();
try {
foreach (var child in parent.GetDirectories())
{
string reason;
if (!filter.InvalidFolderNamesFilter.CheckFolderName(child.Name, out reason) && !filter.FolderNamesFilter.CheckFolderName(child.Name, out reason) && !filter.SymlinkFilter.IsSymlink(child, out reason))
{
children.Add(GetLocalDirectoryTree(child, filter));
}
else
{
Logger.Info(reason);
}
}
foreach (var file in parent.GetFiles())
{
string reason;
if (!filter.FileNamesFilter.CheckFile(file.Name, out reason) && !filter.SymlinkFilter.IsSymlink(file, out reason))
{
children.Add(new ObjectTree <IFileSystemInfo> {
Item = file,
Children = new List <IObjectTree <IFileSystemInfo> >()
});
}
else
{
Logger.Info(reason);
}
}
} catch (System.IO.PathTooLongException) {
Logger.Fatal(string.Format("One or more children paths of \"{0}\" are to long to be synchronized, synchronization is impossible since the problem is fixed", parent.FullName));
throw;
}
IObjectTree <IFileSystemInfo> tree = new ObjectTree <IFileSystemInfo> {
Item = parent,
Children = children
};
return(tree);
}
private static void AssurePathExists(IDirectoryInfo dirInfo, Queue <string> nameSpaceParts)
{
if (!nameSpaceParts.Any())
{
return;
}
var nextPart = nameSpaceParts.Dequeue();
var subDirectories = dirInfo.GetDirectories();
var nextDirectory = subDirectories.SingleOrDefault(f => f.Name == nextPart);
if (nextDirectory == null)
{
nextDirectory = dirInfo.CreateSubdirectory(nextPart);
}
AssurePathExists(nextDirectory, nameSpaceParts);
}
public void CopyAll(IDirectoryInfo source, IDirectoryInfo target)
{
directory.CreateDirectory(target.FullName);
// Copy each file into the new directory.
foreach (IFileInfo fi in source.GetFiles())
{
fi.CopyTo(path.Combine(target.FullName, fi.Name), true);
}
// Copy each subdirectory using recursion.
foreach (IDirectoryInfo diSourceSubDir in source.GetDirectories())
{
IDirectoryInfo nextTargetSubDir =
target.CreateSubdirectory(diSourceSubDir.Name);
CopyAll(diSourceSubDir, nextTargetSubDir);
}
}
// ******************************************************************************
/// <summary>
/// Returns a fully populate heirarchy for this key
/// </summary>
/// <param name="directoryInfo">Object representing the root key to scan</param>
/// <returns>Populated Heirarchy</returns>
// ******************************************************************************
RegistryItem ScanRegistry(IDirectoryInfo registryInfo, CancellationToken cancelToken)
{
CurrentItemLabel = registryInfo.FullName;
RegistryItem thisKey = new RegistryItem(registryInfo.Name, registryInfo.FullName);
if (cancelToken.IsCancellationRequested)
{
return(thisKey);
}
try
{
//Total up the size of the content
foreach (var registryItem in registryInfo.GetFiles())
{
thisKey.AddContent(registryItem.Name, registryItem);
UnitsScannedSoFar += registryItem.GetValue(RegistryDirectoryInfo.ITEMSIZE);
if (cancelToken.IsCancellationRequested)
{
return(thisKey);
}
}
// recurse into the sub keys
foreach (IDirectoryInfo key in registryInfo.GetDirectories())
{
RegistryItem newKey = ScanRegistry(key, cancelToken);
thisKey.AddChild(newKey);
}
}
//Ignore permission problems, since if a standare user runs the tool then there
// will be KEYS that they dont't have access to but we want to skip pass and process
// the rest of the hive anyways.
catch (SecurityException) { }
catch (Exception e)
{
#if DEBUG
Debugger.Break();
#endif
Debug.WriteLine("Error: " + e.Message);
}
return(thisKey);
}
public static List <IFileInfo> GetAllFiles(IDirectoryInfo dir, List <IFileInfo> files = null, int?level = null, int?maxlevel = null)
{
if (files == null)
{
files = new List <IFileInfo>();
}
if (level != null && maxlevel != null)
{
if (level.Value > maxlevel.Value)
{
return(files);
}
}
try
{
if (level != null)
{
level++;
}
foreach (var d in dir.GetDirectories())
{
GetAllFiles(d, files, level, maxlevel);
}
}
catch (UnauthorizedAccessException ex)
{
}
catch (Exception ex)
{
//generate error
}
try
{
foreach (var file in dir.GetFiles())
{
files.Add(file);
}
}
catch (Exception ex)
{
}
return(files);
}
private string GetLogDirectory()
{
if (_logDirectoryPath == null)
{
lock (_logDirectoryPathLock)
{
if (_logDirectoryPath == null)
{
string basePath = _fileSystem.Path.Combine(_dataDirectory.ResolvedPath, InMemoryDirectory);
IDirectoryInfo baseDirectoryInfo = _fileSystem.DirectoryInfo.FromDirectoryName(basePath);
if (!baseDirectoryInfo.Exists)
{
baseDirectoryInfo.Create();
}
IDirectoryInfo[] existingLogDirectories = baseDirectoryInfo.GetDirectories("log*");
int existingSuffix = existingLogDirectories.Select(x =>
{
if (int.TryParse(x.Name.Substring(3), out int suffix))
{
return(suffix);
}
return(0);
})
.DefaultIfEmpty()
.Max();
int newSuffix = existingSuffix + 1;
string logDirectoryName = $"log{newSuffix:0000}";
if (_logger.IsDebug())
{
LogDebug.CreatingMemoryStoreLogDirectory(_logger, logDirectoryName,
baseDirectoryInfo.FullName, null);
}
IDirectoryInfo logDirectory = baseDirectoryInfo.CreateSubdirectory(logDirectoryName);
_logDirectoryPath = logDirectory.FullName;
}
}
}
return(_logDirectoryPath);
}
private void ScanSubFoldersForOldFiles(string folderToScan, DateTime oldestEpisodeToKeep, List <IFileInfo> episodesToDelete, PodcastInfo podcastInfo)
{
IDirectoryInfo directoryInfo = _directoryInfoProvider.GetDirectoryInfo(folderToScan);
IDirectoryInfo[] subFolders;
try
{
subFolders = directoryInfo.GetDirectories("*.*");
}
catch (DirectoryNotFoundException)
{
// if the folder is not there then there is nothing to do
return;
}
foreach (IDirectoryInfo subFolder in subFolders)
{
ScanFolderForOldFiles(subFolder.FullName, oldestEpisodeToKeep, episodesToDelete, podcastInfo);
}
}
bool doesFolderContainAspxFiles(IDirectoryInfo di, int callLevel)
{
if (di.Name.ToLower() == "node_modules") return false;
if (callLevel > 6) return false;
try {
if (di.GetFiles("*.aspx").Length > 0) return true;
foreach (var sdi in di.GetDirectories()) {
if (doesFolderContainAspxFiles(sdi, callLevel + 1)) return true;
}
} catch (PathTooLongException) { }
return false;
}
public FolderTree(IDirectoryInfo dir, string name = null) {
this.Name = name ?? dir.Name;
this.IsFile = false;
this.LocalId = dir.Uuid == null ? null : dir.Uuid.GetValueOrDefault().ToString();
foreach (var child in dir.GetDirectories()) {
this.children.Add(new FolderTree(child));
}
this.children.Sort((FolderTree x, FolderTree y) => x.Name.CompareTo(y.Name));
}
/// <summary>
/// Creates a test directory with the specified name under the TV directory.
/// </summary>
/// <param name="parent">
/// The parent directory.
/// </param>
/// <param name="names">
/// The names of the directories to create.
/// </param>
/// <returns>
/// The directory info.
/// </returns>
protected IDirectoryInfo[] CreateTestDirectory(IDirectoryInfo parent, params string[] names)
{
var directories = new IDirectoryInfo[names.Length];
for (int i = 0; i < names.Length; i++)
{
var directory = Substitute.For<IDirectoryInfo>();
directory.Name.Returns(names[i]);
string fullName = names[i];
if (parent != null)
{
fullName = parent.FullName + Path.DirectorySeparatorChar + names[i];
}
directory.FullName.Returns(fullName);
directory.Exists.Returns(true);
directories[i] = directory;
}
if (parent != null)
{
parent.GetDirectories().Returns(directories);
}
return directories;
}
/// <summary>
/// Scans a directory recursively.
/// </summary>
/// <param name="rootDirectory">The root directory.</param>
private void ScanDirectories(IDirectoryInfo rootDirectory)
{
if (this.IsStopped) { return; }
try
{
if (rootDirectory.Exists)
{
IEnumerable<IFileInfo> files = rootDirectory.GetFiles();
foreach (IFileInfo file in files)
{
if (this.IsStopped) { return; }
if (file.Exists)
{
this.OnFileFound(new FileFoundEventArgs(file));
}
}
IEnumerable<IDirectoryInfo> directories = rootDirectory.GetDirectories();
foreach (IDirectoryInfo directory in directories)
{
if (this.IsStopped)
{
return;
}
if (directory.Name == "$RECYCLE.BIN" || !directory.Exists)
{
continue;
}
this.OnDirectoryFound(new DirectoryFoundEventArgs(directory));
this.ScanDirectories(directory);
}
}
}
// Catch the exceptions and don't handle anything,
// we want to skip those files or directories
catch (UnauthorizedAccessException)
{
}
catch (SecurityException)
{
}
catch (IOException)
{
}
this.OnDirectoryProceeded(EventArgs.Empty);
}
/// <summary>
/// Processes the specified directory looking for episodes.
/// </summary>
/// <param name="directory">
/// The directory to search.
/// </param>
/// <param name="overrideRecurse">
/// A value indicating whether the setting for recurse subdirectories should be overriden.
/// </param>
/// <param name="ignoreShowUpdate">
/// A value indicating whether the settings for updating and locked shows should be ignored.
/// </param>
/// <returns>
/// The list of identified files.
/// </returns>
private IEnumerable<FileResult> ProcessDirectory(
IDirectoryInfo directory, bool overrideRecurse = false, bool ignoreShowUpdate = false)
{
// Get the files where the extension is in the list of extensions.
IEnumerable<IFileInfo> files =
directory.GetFiles().Where(file => this.settings.FileExtensions.Contains(file.Extension));
foreach (FileResult result in files.Select(info => this.ProcessFile(info, ignoreShowUpdate)))
{
if (result != null)
{
yield return result;
}
}
// If ignore show update is on then this is being run from the FileManger as part
// of a move or copy operation. It should add to log that it is scanning the directory.
if (!ignoreShowUpdate)
{
Logger.OnLogMessage(this, "Scanned directory: {0}", LogType.Info, directory.FullName.Truncate());
}
if (!this.settings.RecurseSubdirectories && !overrideRecurse)
{
yield break;
}
IDirectoryInfo[] dirs = directory.GetDirectories().Where(d => !d.DirectoryAttributes.HasFlag(FileAttributes.System)
&& !settings.IgnoredDirectories.Contains(d.FullName)).ToArray();
foreach (FileResult result in
dirs.SelectMany(dir => this.ProcessDirectory(dir, overrideRecurse, ignoreShowUpdate)))
{
yield return result;
}
}
bool doesFolderContainCssFiles(IDirectoryInfo di)
{
if (di.FullName.Contains("\\App_Themes\\Default\\WAF\\")) return false;
if (di.GetFiles("*.css").Length > 0) return true;
foreach (var sdi in di.GetDirectories()) {
if (doesFolderContainCssFiles(sdi)) return true;
}
return false;
}
bool doesFolderContainAspxFiles(IDirectoryInfo di)
{
if (di.GetFiles("*.aspx").Length > 0) return true;
foreach (var sdi in di.GetDirectories()) {
if (doesFolderContainAspxFiles(sdi)) return true;
}
return false;
}
private void AddDirectoryToZipFile (IDirectoryInfo directoryInfo, ZipOutputStream zipOutputStream, ZipNameTransform nameTransform)
{
foreach (var file in directoryInfo.GetFiles ())
AddFileToZipFile (file, zipOutputStream, nameTransform);
foreach (var directory in directoryInfo.GetDirectories ())
AddDirectoryToZipFile (directory, zipOutputStream, nameTransform);
}
/// <summary>
/// Gets the local directory tree.
/// </summary>
/// <returns>The local directory tree.</returns>
/// <param name="parent">Parent directory.</param>
/// <param name="filter">Filter for files.</param>
public static IObjectTree<IFileSystemInfo> GetLocalDirectoryTree(IDirectoryInfo parent, IFilterAggregator filter) {
var children = new List<IObjectTree<IFileSystemInfo>>();
try {
foreach (var child in parent.GetDirectories()) {
string reason;
if (!filter.InvalidFolderNamesFilter.CheckFolderName(child.Name, out reason) && !filter.FolderNamesFilter.CheckFolderName(child.Name, out reason) && !filter.SymlinkFilter.IsSymlink(child, out reason)) {
children.Add(GetLocalDirectoryTree(child, filter));
} else {
Logger.Info(reason);
}
}
foreach (var file in parent.GetFiles()) {
string reason;
if (!filter.FileNamesFilter.CheckFile(file.Name, out reason) && !filter.SymlinkFilter.IsSymlink(file, out reason)) {
children.Add(new ObjectTree<IFileSystemInfo> {
Item = file,
Children = new List<IObjectTree<IFileSystemInfo>>()
});
} else {
Logger.Info(reason);
}
}
} catch (System.IO.PathTooLongException) {
Logger.Fatal(string.Format("One or more children paths of \"{0}\" are to long to be synchronized, synchronization is impossible since the problem is fixed", parent.FullName));
throw;
}
IObjectTree<IFileSystemInfo> tree = new ObjectTree<IFileSystemInfo> {
Item = parent,
Children = children
};
return tree;
}
