|
public static EnumerateDirectories ( string path ) : System.Collections.Generic.IEnumerable |
||
| path | string | |
| return | System.Collections.Generic.IEnumerable |
|
public IEnumerable <string> GetRoots()
{
ConcurrentQueue <string> inputs = new ConcurrentQueue <string>();
var items = _configuration.GetValues(PATHS_SETTING)
.Where(p => !(string.IsNullOrWhiteSpace(p)));
foreach (var item in items)
{
yield return(item);
inputs.Enqueue(item);
}
string current = null;
while (inputs.TryDequeue(out current))
{
var childItems = Directory.EnumerateDirectories(current);
foreach (var item in childItems)
{
yield return(item);
inputs.Enqueue(item);
}
}
}
private void CopyDirectory(string sourceFolder, string destinationFolder)
{
// check that source and destination folders exist
if (!sourceFolder.DirectoryExists() || !destinationFolder.DirectoryExists())
{
return;
}
// copy the files over
foreach (var file in Directory.EnumerateFiles(sourceFolder))
{
File.Copy(file, Path.Combine(destinationFolder, Path.GetFileName(file)), true);
}
// copy the directories over
foreach (var directory in Directory.EnumerateDirectories(sourceFolder))
{
var destinationDirName = Path.Combine(destinationFolder, Path.GetFileName(directory));
if (!Directory.Exists(destinationDirName))
{
Directory.CreateDirectory(destinationDirName);
}
CopyDirectory(directory, destinationDirName);
}
}
public void Search_FilteredFileFindedExcludeFileSystemEntry_RiseStartAndFinishEventsFindOnlyDirectories()
{
// Arrange
var fsv = new FileSystemVisitor();
var isStartEventRised = false;
var isFinishEventRised = false;
fsv.Start += (sender, args) => { isStartEventRised = true; };
fsv.Finish += (sender, args) => { isFinishEventRised = true; };
fsv.FilteredFileFinded += (sender, args) => { args.ExcludeFileSystemEntry = true; };
// Act
var findedEntries = fsv.Search(TestRootDirectoryName).ToArray();
// Assert
Assert.IsTrue(isStartEventRised);
Assert.IsTrue(isFinishEventRised);
var expectedEntries = DirectoryHelper.EnumerateDirectories(TestRootDirectoryName, "*", SearchOption.AllDirectories).ToArray();
Assert.IsTrue(ArrayHelper.Compare(
expectedEntries,
findedEntries,
StringComparison)
);
}
public static IEnumerable <Backup> EnumerateBackups(bool isMac)
{
string backupRootPath;
if (isMac)
{
backupRootPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Personal),
"Library",
"ApplicationSupport",
"MobileSync",
"Backup"
);
}
else
{
backupRootPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
"Apple Computer",
"MobileSync",
"Backup"
);
}
if (!IODirectory.Exists(backupRootPath))
{
yield break;
}
foreach (var backupDirectory in IODirectory.EnumerateDirectories(backupRootPath))
{
// Check if this is a backup we can deal with. It has to have an Info.plist and a Manifest.db.
var plistFile = Path.Combine(backupDirectory, "Info.plist");
var manifest = Path.Combine(backupDirectory, "Manifest.db");
if (!IOFile.Exists(plistFile) || !IOFile.Exists(manifest))
{
continue;
}
var plist = PDictionary.FromFile(plistFile);
var backup = new Backup {
BackupPath = backupDirectory,
DeviceName = plist.GetString("Device Name"),
OSVersion = Version.Parse(plist.GetString("Product Version")),
ProductName = plist.GetString("Product Name"),
ProductType = plist.GetString("Product Type"),
SerialNumber = plist.GetString("Serial Number"),
BackupTime = plist.Get <PDate>("Last Backup Date").Value,
};
yield return(backup);
}
}
private void RecursiveDeleteEmptyDirectories(string dir, bool importfolder)
{
try
{
if (string.IsNullOrEmpty(dir))
{
return;
}
if (!Directory.Exists(dir))
{
return;
}
if (IsDirectoryEmpty(dir))
{
if (importfolder)
{
return;
}
try
{
Directory.Delete(dir);
}
catch (Exception ex)
{
if (ex is DirectoryNotFoundException || ex is FileNotFoundException)
{
return;
}
logger.Warn("Unable to DELETE directory: {0} Error: {1}", dir,
ex);
}
return;
}
// If it has folder, recurse
foreach (string d in Directory.EnumerateDirectories(dir))
{
RecursiveDeleteEmptyDirectories(d, false);
}
}
catch (Exception e)
{
if (e is FileNotFoundException || e is DirectoryNotFoundException)
{
return;
}
logger.Error($"There was an error removing the empty directory: {dir}\r\n{e}");
}
}
private static IEnumerable <string> EnumerateDirectoriesInternal(
string path,
string searchPattern,
bool recursively)
{
var localPath = Requires.NotNullOrWhiteSpace(
path,
nameof(path));
var localSearchPattern = Requires.NotNullOrWhiteSpace(
searchPattern,
nameof(searchPattern));
return(FSDir.EnumerateDirectories(
localPath,
localSearchPattern,
recursively ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly));
}
private void RemoveDirectory(string directoryFolder)
{
// remove all files
foreach (var fileToBeRemoved in Directory.EnumerateFiles(directoryFolder))
{
fileToBeRemoved.TryHardToDelete();
}
// remove all subdirectories
foreach (var folderToBeRemoved in Directory.EnumerateDirectories(directoryFolder))
{
RemoveDirectory(folderToBeRemoved);
}
try
{
// now try to remove the directory
Directory.Delete(directoryFolder);
}
catch { }
}
public void Search_DirectoryFindedWithFalseFilter_RiseEventForEachSubdirectoryInDirectory()
{
// Arrange
var fsv = new FileSystemVisitor((path) => false);
var findedDirectories = new List <string>();
fsv.DirectoryFinded += (sender, args) => { findedDirectories.Add(args.Path); };
// Act
fsv.Search(TestRootDirectoryName).ToArray();
// Assert
var expectedEntries = DirectoryHelper.EnumerateDirectories(TestRootDirectoryName, "*", SearchOption.AllDirectories).ToArray();
Assert.IsTrue(ArrayHelper.Compare(
expectedEntries,
findedDirectories.ToArray(),
StringComparison)
);
}
private static Task <IEnumerable <string> > EnumerateDirectoriesInternalAsync(
string path,
string searchPattern,
bool recursively,
CancellationToken cancellationToken)
{
var localPath = Requires.NotNullOrWhiteSpace(
path,
nameof(path));
var localSearchPattern = Requires.NotNullOrWhiteSpace(
searchPattern,
nameof(searchPattern));
return(Work.OnThreadPoolAsync(
state => FSDir.EnumerateDirectories(
state.Path,
state.Pattern,
state.Recursive),
(Path: localPath, Pattern: localSearchPattern, Recursive: recursively ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly),
cancellationToken));
}
/// <summary>
/// Extract zipped package and return the unzipped folder
/// </summary>
/// <param name="zippedPackagePath"></param>
/// <returns></returns>
private string ExtractZipPackage(string zippedPackagePath)
{
if (zippedPackagePath != null && zippedPackagePath.FileExists())
{
// extracted folder
string extractedFolder = FilesystemExtensions.GenerateTemporaryFileOrDirectoryNameInTempDirectory();
try
{
//unzip the file
ZipFile.ExtractToDirectory(zippedPackagePath, extractedFolder);
// extraction fails
if (!Directory.Exists(extractedFolder))
{
Verbose(string.Format(CultureInfo.CurrentCulture, Resources.Messages.FailToExtract, zippedPackagePath, extractedFolder));
return(string.Empty);
}
// the zipped folder
var zippedDirectory = Directory.EnumerateDirectories(extractedFolder).FirstOrDefault();
if (!string.IsNullOrWhiteSpace(zippedDirectory) && Directory.Exists(zippedDirectory))
{
return(zippedDirectory);
}
}
catch (Exception ex)
{
Verbose(string.Format(CultureInfo.CurrentCulture, Resources.Messages.FailToInstallZipFolder, zippedPackagePath, ex.Message));
Debug(ex.StackTrace);
// remove the extracted folder
extractedFolder.TryHardToDelete();
}
}
return(string.Empty);
}
public bool DeleteEntries()
{
void DeleteCore(string path)
{
foreach (var file in D.EnumerateFiles(path))
{
File.Delete(file);
}
foreach (var dir in D.EnumerateDirectories(path))
{
DeleteCore(dir);
D.Delete(dir);
}
}
if (!this.Exists())
{
return(false);
}
DeleteCore(this.FullName);
return(true);
}
public static void CopyDirectory(string source, string destination)
{
IoDir.CreateDirectory(source);
IoDir.CreateDirectory(destination);
foreach (var dirPath in IoDir.EnumerateDirectories(source, "*", SearchOption.AllDirectories))
{
try {
IoDir.CreateDirectory(dirPath.Replace(source, destination));
}
catch (Exception) {
Bash.Execute($"mkdir -p {dirPath.Replace(source, destination)}", false);
}
}
foreach (var newPath in IoDir.EnumerateFiles(source, "*", SearchOption.AllDirectories))
{
try {
File.Copy(newPath, newPath.Replace(source, destination), true);
}
catch (Exception) {
Bash.Execute($"cp {newPath} {newPath.Replace(source, destination)}", false);
}
}
}
/// <summary>
/// Copies a directory to a new location including all files and folders beneath it.
/// Creates a new directory if necessary.
/// </summary>
/// <param name="path">The path of the directory to copy.</param>
/// <param name="newPath">The destination path to copy the directory to.</param>
/// <param name="overwrite">Whether to overwrite any existing files in the directory being copied to.</param>
/// <returns>True if the directory was copied. False otherwise.</returns>
static public bool Copy(string path, string newPath, bool overwrite = false)
{
if (!string.IsNullOrEmpty(path) && !string.IsNullOrEmpty(newPath))
{
// Ensure that the paths end in a slash.
if (!path.EndsWith(@"\"))
{
// Add the slash.
path += @"\";
}
if (!newPath.EndsWith(@"\"))
{
// Add the slash.
newPath += @"\";
}
// Determine if the path is a directory.
if (SystemDirectory.Exists(path))
{
// It is a directory.
try
{
// Check whether the directory to copy to exists.
if (!SystemDirectory.Exists(newPath))
{
// Clone a new directory to copy the directory into.
// This ensures we get the same permissions.
if (!Clone(path, newPath))
{
// The directory couldn't be cloned.
return(false);
}
}
// Copy the contents of subdirectories.
foreach (string directoryName in SystemDirectory.EnumerateDirectories(path))
{
// Get the name of the subdirectory.
string subDirectoryName = directoryName.Substring(path.Length);
// Recursively copy the directory.
if (!Copy(directoryName, newPath + subDirectoryName + @"\", overwrite))
{
// The directory couldn't be copied.
return(false);
}
}
// Copy any files in the directory.
foreach (string fileName in SystemDirectory.EnumerateFiles(path))
{
FileInfo originalFileInfo = new FileInfo(fileName);
if (!File.Copy(fileName, newPath, overwrite))
{
// The file couldn't be copied.
return(false);
}
}
return(true);
}
catch
{
// There was an error copying the directory or its contents.
return(false);
}
}
}
// The path or newPath were null, or the path to clone did not exist.
return(false);
}
public IEnumerable <FileSystemPath> EnumerateAllEntries(string searchPattern = "*") => D.EnumerateDirectories(this.FullName, searchPattern, SearchOption.AllDirectories).Select(x => (FileSystemPath) new DirectoryPath(x, false)) .Concat(D.EnumerateFiles(this.FullName, searchPattern, SearchOption.AllDirectories).Select(x => (FileSystemPath) new FilePath(x, false)));
public IEnumerable <DirectoryPath> EnumerateAllDirectories(string searchPattern = "*") => D.EnumerateDirectories(this.FullName, searchPattern, SearchOption.AllDirectories).Select(x => new DirectoryPath(x, false));
private IEnumerable <DriveItem> SafelyEnumerateDriveItems(string folderPath, CryptoDriveContext context, [CallerMemberName] string callerName = "")
{
var forceNew = callerName == nameof(this.SafelyEnumerateDriveItems);
var driveItems = Enumerable.Empty <DriveItem>();
var absoluteFolderPath = folderPath.ToAbsolutePath(this.BasePath);
try
{
// get all folders in current folder
driveItems = driveItems.Concat(Directory.EnumerateDirectories(absoluteFolderPath, "*", SearchOption.TopDirectoryOnly)
.SelectMany(current =>
{
RemoteState oldRemoteState = null;
var driveInfo = new DirectoryInfo(current).ToDriveItem(this.BasePath);
var folderPath2 = current.Substring(this.BasePath.Length).NormalizeSlashes();
if (!forceNew)
{
oldRemoteState = context.RemoteStates.FirstOrDefault(remoteState => remoteState.GetItemPath() == folderPath2 &&
remoteState.Type == DriveItemType.Folder);
}
// When we know that the parent folder is not in the database (oldRemoteState == null),
// the children aren't there neither (forceNew = true).
if (forceNew || oldRemoteState == null)
{
return(this.SafelyEnumerateDriveItems(folderPath2, context)
.Concat(new DriveItem[] { driveInfo }));
}
else
{
return new List <DriveItem> {
driveInfo
}
};
}));
// get all files in current folder
driveItems = driveItems.Concat(Directory.EnumerateFiles(absoluteFolderPath)
.SelectMany(current =>
{
var driveInfo = new FileInfo(current).ToDriveItem(this.BasePath);
return(new List <DriveItem> {
driveInfo
});
}).ToList());
// get all deleted items
var remoteStates = context.RemoteStates.Where(current => current.Path == folderPath);
var deletedItems = remoteStates.Where(current =>
{
switch (current.Type)
{
case DriveItemType.Folder:
return(!Directory.Exists(current.GetItemPath().ToAbsolutePath(this.BasePath)));
case DriveItemType.File:
return(!File.Exists(current.GetItemPath().ToAbsolutePath(this.BasePath)));
case DriveItemType.RemoteItem:
default:
throw new NotSupportedException();
}
}).Select(current => current.ToDriveItem(deleted: true));
driveItems = driveItems.Concat(deletedItems);
return(driveItems);
}
catch (UnauthorizedAccessException)
{
return(driveItems);
}
}