public void FinishTest()
{
if (_directoryWrap.Exists(path))
{
_directoryWrap.Delete(path, true);
}
}
private void DeleteTemporaryOutput(string jobTempFolder)
{
if (!string.IsNullOrEmpty(jobTempFolder) && Path.IsPathRooted(jobTempFolder) &&
_directory.Exists(jobTempFolder))
{
try
{
_directory.Delete(jobTempFolder, true);
}
catch (IOException ex)
{
_logger.Warn("Error while deleting temporary folder: " + ex.Message);
}
}
}
public static void DeleteEntireFolder(
this IDirectory system,
DirectoryPath path,
bool disableReadOnly = true,
bool deleteFolderItself = true)
{
if (!system.Exists(path))
{
return;
}
string[] files = system.GetFiles(path);
var exceptions = new List <Exception>();
foreach (string f in files)
{
var fi = system.FileSystem.FileInfo.FromFileName(f);
if (disableReadOnly)
{
if (fi.IsReadOnly)
{
fi.IsReadOnly = false;
}
}
try
{
fi.Delete();
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
foreach (string subDir in system.GetDirectories(path))
{
system.DeleteEntireFolder(subDir, disableReadOnly);
}
if (deleteFolderItself)
{
if (system.GetFiles(path).Length == 0 &&
system.GetDirectories(path).Length == 0)
{
try
{
system.Delete(path);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
}
if (exceptions.Count == 1)
{
throw exceptions[0];
}
if (exceptions.Count > 1)
{
throw new AggregateException(exceptions);
}
}
private static void ParsePluginConfigs(IEnumerable <string> directories)
{
// todo use linq when diable plugin is implemented since parallel.foreach + list is not thread saft
foreach (var directory in directories)
{
if (File.Exists(Path.Combine(directory, "NeedDelete.txt")))
{
try
{
Directory.Delete(directory, true);
}
catch (Exception e)
{
Log.Exception($"Can't delete <{directory}>", e, MethodBase.GetCurrentMethod().DeclaringType);
}
}
else
{
PluginMetadata metadata = GetPluginMetadata(directory);
if (metadata != null)
{
PluginMetadatas.Add(metadata);
}
}
}
}
private void RecursiveDeleteEmptyDirectories(IDirectory dir, bool importfolder)
{
FileSystemResult fr = dir.Populate();
if (fr.IsOk)
{
if (dir.Files.Count > 0)
{
return;
}
foreach (IDirectory d in dir.Directories)
{
RecursiveDeleteEmptyDirectories(d, false);
}
}
if (importfolder)
{
return;
}
fr = dir.Populate();
if (fr.IsOk)
{
if (dir.Files.Count == 0 && dir.Directories.Count == 0)
{
fr = dir.Delete(true);
if (!fr.IsOk)
{
logger.Warn("Unable to DELETE directory: {0} error {1}", dir.FullName, fr?.Error ?? String.Empty);
}
}
}
}
public static void DeleteWithTimeout(this IDirectory directory)
{
int retryCount = 0;
while (retryCount++ < RetryCount)
{
try
{
if (directory.Exists)
{
directory.Delete();
}
return;
}
catch (IOException ex)
{
if (retryCount == RetryCount)
{
throw ex;
}
else
{
Thread.Sleep(RetryWaitInterval);
}
}
}
}
/// <summary>
/// Deletes all parent directories that had to be created to reach the requested directory.
/// If a parent directory contains files, it will not be deleted, likewise further parent directories.
/// </summary>
/// <returns>false if deleting directory throws exception</returns>
public bool DeleteCreatedDirectories()
{
_createdDirectories = CreatedDirectories.OrderByDescending(x => x).ToList(); //start with tallest
foreach (var createdDirectory in _createdDirectories)
{
if (!_directoryWrap.Exists(createdDirectory))
{
continue;
}
if (_directoryWrap.EnumerateFileSystemEntries(createdDirectory).Any())
{
continue;
}
try
{
_directoryWrap.Delete(createdDirectory);
_logger.Debug("Deleted previously created but unused directory " + createdDirectory);
}
catch (Exception ex)
{
_logger.Warn("Exception while deleting created but unused directory \"" + createdDirectory + "\"\r\n" + ex.Message);
return(false);
}
}
return(true);
}
public void DeleteDir()
{
if (!string.IsNullOrEmpty(_inputPath) && dirHelper.Exists(_inputPath))
{
dirHelper.Delete(_inputPath, true);
}
}
/// <summary>
/// 清空发布文件
/// </summary>
protected void ClearReleaseDir(IBuildContext context)
{
IDirectory releaseDir = context.Disk.Directory(context.ReleasePath, PathTypes.Absolute);
releaseDir.Delete();
releaseDir.Create();
}
public void Cleanup()
{
if (_directoryWrapper == null)
{
_directoryWrapper = new DirectoryWrapper();
}
_directoryWrapper.Delete(EnvironmentVariables.DetailLogPath, true);
}
static void ProcessDirectory(IDirectory Directory)
{
if (Directory.Empty)
{
System.Console.WriteLine("{0} is empty", Directory);
Directory.Delete();
}
}
public void DeleteAllTests(Guid resourceId)
{
var dirPath = GetTestPathForResourceId(resourceId);
if (_directoryWrapper.Exists(dirPath))
{
_directoryWrapper.Delete(dirPath, true);
Tests.TryRemove(resourceId, out List <IServiceTestModelTO> removedTests);
}
}
public void DeleteAllCoverageReports(Guid resourceId)
{
var dirPath = GetTestCoveragePathForResourceId(resourceId);
if (_directoryWrapper.Exists(dirPath))
{
_directoryWrapper.Delete(dirPath, true);
TestCoverageReports.TryRemove(resourceId, out _);
}
}
void DeletePath(string path)
{
if (IsDirectory(path))
{
_directory.Delete(path, true);
}
else
{
_file.Delete(path);
}
}
public static bool TryDelete(this IDirectory directory, string dirPath)
{
try
{
directory.Delete(dirPath);
return(true);
}
catch
{
return(false);
}
}
public void GivenReadOnlyFileSystem_WhenRequestDirectory_ThenCannotDeleteDirectory()
{
IFileSystem roFileSystem = new ReadOnlyFileSystemDecorator(mockFileSystem.Object);
Mock <IDirectory> mockDirectory = new Mock <IDirectory>();
mockFileSystem.Setup(fs => fs.Directory("/")).Returns(mockDirectory.Object);
IDirectory directory = roFileSystem.Directory("/");
Assert.Throws <NotSupportedException>(() => directory.Delete());
}
public void DirectoryRenameTest()
{
var Manager = new FileManager();
IDirectory TempObject = Manager.Directory("~/Data/Test");
TempObject.Create();
string DirectoryPath = TempObject.Parent.FullName;
TempObject.Rename("Test2");
Assert.Equal(DirectoryPath + "\\Test2", TempObject.FullName);
TempObject.Delete();
}
public static bool TryDelete(this IDirectory directory, string dirPath)
{
Guard.Against.NullOrWhiteSpace(dirPath, nameof(dirPath));
try
{
directory.Delete(dirPath);
return(true);
}
catch
{
return(false);
}
}
public void DirectoryMoveToTest()
{
var Manager = new FileManager();
IDirectory TempObject = Manager.Directory("~/Data/Test");
TempObject.Create();
IDirectory NewParent = Manager.Directory("~/Data2/");
NewParent.Create();
TempObject.MoveTo(NewParent);
Assert.Equal(NewParent.FullName + "Test", TempObject.FullName);
TempObject.Delete();
}
private static async Task MoveUsingStreams(IDirectory destination, IDirectory source, CancellationToken token)
{
destination.Create();
foreach (var subDir in source.AllSubDirectories())
{
await MoveUsingStreams(destination.SubDirectory(subDir.Name), subDir, token);
}
foreach (var file in source.AllFiles())
{
await MoveUsingStreams(destination.File(file.Name), file, token, source.Attributes);
}
source.Delete();
}
public void DeleteDir()
{
if (!string.IsNullOrEmpty(_inputPath) && dirHelper.Exists(_inputPath))
{
try
{
dirHelper.Delete(_inputPath, true);
}
catch (IOException e)
{
Console.WriteLine($"Error during cleanup {e.Message}");
}
}
}
public static void DeleteDirectoryAndCheckForException(this IDirectory directory, string path)
{
try
{
if (directory.Exists(path))
{
directory.Delete(path, true);
}
}
catch (Exception ex)
{
Log.Error($"Failed to delete baseline directory: {ex.Message}");
}
}
static void CollapseDirectory(IDirectory DestinationDirectory, IDirectory SubDir)
{
if (SubDir == DestinationDirectory)
{
return;
}
foreach (IFile File in SubDir.Files)
{
File.MoveTo(DestinationDirectory);
}
SubDir.Delete();
}
public IList <IExplorerItem> DeleteVersion(Guid resourceId, string versionNumber, string resourcePath)
{
var resource = _catalogue.GetResource(Guid.Empty, resourceId);
var versionFolder = GetVersionFolderPath(resource.ResourceID.ToString());
var allVersions = _directory.GetFiles(versionFolder);
var version = allVersions.FirstOrDefault(p => _filePath.GetFileName(p)
.StartsWith(versionNumber, StringComparison.Ordinal));
_file.Delete(version);
if (_directory.GetFiles(versionFolder).Length < 1)
{
_directory.Delete(versionFolder, true);
}
return(GetVersions(resourceId));
}
public void finds_directory(string directoryPath, string searchString)
{
IDirectory folder = null;
try
{
folder = FileSystem.GetDirectory(directoryPath).MustExist();
FileSystem.GetCurrentDirectory().Directories(searchString, SearchScope.CurrentOnly)
.ShouldHaveCountOf(1)
.First().Path.FullPath.ShouldBe(directoryPath);
}
finally
{
folder.Delete();
}
}
/// <summary>
/// Deletes the output path and all files it contains.
/// </summary>
public void CleanOutputPath()
{
try
{
_logger.LogDebug($"Cleaning output directory: {FileSystem.OutputPath}...");
IDirectory outputDirectory = FileSystem.GetOutputDirectory();
if (outputDirectory.Exists)
{
outputDirectory.Delete(true);
}
_logger.LogInformation($"Cleaned output directory: {FileSystem.OutputPath}");
}
catch (Exception ex)
{
_logger.LogWarning("Error while cleaning output directory: {0} - {1}", ex.GetType(), ex.Message);
}
}
/// <summary>
/// Deletes the temp path and all files it contains.
/// </summary>
public void CleanTempPath()
{
try
{
Trace.Information("Cleaning temp path: {0}", FileSystem.TempPath);
IDirectory tempDirectory = FileSystem.GetTempDirectory();
if (tempDirectory.Exists)
{
tempDirectory.Delete(true);
}
Trace.Information("Cleaned temp directory");
}
catch (Exception ex)
{
Trace.Warning("Error while cleaning temp path: {0} - {1}", ex.GetType(), ex.Message);
}
}
/// <summary>
/// Deletes the output path and all files it contains.
/// </summary>
public void CleanOutputPath()
{
try
{
Trace.Information("Cleaning output path: {0}", FileSystem.OutputPath);
IDirectory outputDirectory = FileSystem.GetOutputDirectory();
if (outputDirectory.Exists)
{
outputDirectory.Delete(true);
}
Trace.Information("Cleaned output directory");
}
catch (Exception ex)
{
Trace.Warning("Error while cleaning output path: {0} - {1}", ex.GetType(), ex.Message);
}
}
/// <summary>
/// Create unique job folder in spool folder and copy ps file to it.
/// Create inf file from ps file.
/// </summary>
/// <returns>inf file in spool folder</returns>
public string TransformToInfFileWithMerge(IList <string> directConversionFiles, AppStartParameters appStartParameters)
{
if (directConversionFiles.Count <= 0)
{
return("");
}
foreach (var file in directConversionFiles)
{
if (string.IsNullOrWhiteSpace(file))
{
return("");
}
if (!_file.Exists(file))
{
Logger.Error("The file \"" + file + "\" does not exist.");
return("");
}
}
string jobFolder;
try
{
jobFolder = CreateJobFolderInSpool(directConversionFiles[0]);
}
catch (Exception ex)
{
Logger.Error("Error while creating spool directory for ps-job:\r\n" + ex.Message);
return("");
}
try
{
var jobFolderFile = CopyFilesToJobFolder(jobFolder, directConversionFiles);
return(CreateInfFile(jobFolderFile, jobFolder, appStartParameters));
}
catch (Exception ex)
{
Logger.Error("Error while coping ps-file in spool folder:\r\n" + ex.Message);
_directory.Delete(jobFolder, true); //Delete created folder and files
return("");
}
}
/// <summary>
/// Deletes the temp path and all files it contains.
/// </summary>
public void CleanTempPath()
{
try
{
_logger.LogDebug($"Cleaning temp directory: {FileSystem.TempPath}...");
IDirectory tempDirectory = FileSystem.GetTempDirectory();
if (tempDirectory.Exists)
{
tempDirectory.Delete(true);
}
tempDirectory.Create();
_logger.LogInformation($"Cleaned temp directory: {FileSystem.TempPath}");
}
catch (Exception ex)
{
_logger.LogWarning("Error while cleaning temp directory: {0} - {1}", ex.GetType(), ex.Message);
}
}
public override void DeleteBinding()
{
//TODO: we are assuming the files are not under source control
string configFile = this.GetFullConfigurationFilePath();
if (!fileWrapper.Exists(configFile))
{
Debug.Fail($"Nothing to delete - binding file does not exist: {configFile}");
return;
}
SafePerformFileSystemOperation(() =>
{
fileWrapper.Delete(configFile);
string sonarLintDir = Path.GetDirectoryName(configFile);
directoryWrapper.Delete(sonarLintDir);
});
}
public void DirectoryTest()
{
var Manager = new FileManager();
IDirectory TempObject = Manager.Directory("~/Data/Test");
Assert.Equal(false, TempObject.Exists);
Assert.Equal("Test", TempObject.Name);
Assert.Equal("Data", TempObject.Parent.Name);
Assert.Equal(0, TempObject.Size);
TempObject.Create();
Assert.Equal(true, TempObject.Exists);
Assert.Equal("Test", TempObject.Name);
Assert.Equal("Data", TempObject.Parent.Name);
TempObject.Delete();
Assert.Equal(false, TempObject.Exists);
Assert.Equal("Test", TempObject.Name);
Assert.Equal("Data", TempObject.Parent.Name);
}
private void RecursiveDeleteEmptyDirectories(IDirectory dir, bool importfolder)
{
FileSystemResult fr = dir.Populate();
if (fr.IsOk)
{
if (dir.Files.Count > 0)
return;
foreach (IDirectory d in dir.Directories)
RecursiveDeleteEmptyDirectories(d,false);
}
if (importfolder)
return;
fr = dir.Populate();
if (fr.IsOk)
{
if (dir.Files.Count == 0 && dir.Directories.Count == 0)
{
fr = dir.Delete(true);
if (!fr.IsOk)
{
logger.Warn("Unable to DELETE directory: {0} error {1}", dir.FullName, fr?.Error ?? String.Empty);
}
}
}
}
public void Directory(IDirectory sdir, IDirectory ddir)
{
if (ddir == null || sdir == null) return;
sdir.Source = ddir.Source = sdir;
sdir.Destination = ddir.Destination = ddir;
int con;
if (sdir is LocalDirectory && ddir is LocalDirectory) con = 1;
else {
con = Math.Max(FtpConnections.Count(true, sdir.Url), FtpConnections.Count(false, ddir.Url));
if (ddir is FtpDirectory) {
((FtpDirectory)ddir).TransferProgress = true;
} else if (sdir is FtpDirectory) {
((FtpDirectory)sdir).TransferProgress = true;
}
}
if (con == 0) con = 1;
var list = sdir.List().Where(file => !Silversite.Services.Paths.Match(ExcludePatterns, file.RelativePath)).ToList();
var dlist = ddir.List();
//ddir.CreateDirectory(null);
Parallel.ForEach<FileOrDirectory>(list, new ParallelOptions { MaxDegreeOfParallelism = con },
(src) => {
FileOrDirectory dest = null;
lock(dlist) { if (dlist.Contains(src.Name)) dest = dlist[src.Name]; }
if (dest != null && dest.Class != src.Class && (src.Changed > dest.Changed || Mode == Silversite.Services.Sync.Mode.Clone)) {
ddir.Delete(dest);
dest = null;
}
if (src.Class == ObjectClass.File) { // src is a file
if (dest == null
|| ((Mode == Silversite.Services.Sync.Mode.Update || Mode == Silversite.Services.Sync.Mode.Add) && src.Changed > dest.Changed)
|| (Mode == Silversite.Services.Sync.Mode.Clone && (src.Changed > dest.Changed + dt))) {
var s = sdir.ReadFile(src);
if (s != null) {
using (s) {
ddir.WriteFile(s, src);
}
}
}
} else { // src is a directory
if (dest == null) Directory((IDirectory)src, ddir.CreateDirectory(src));
else Directory((IDirectory)src, (IDirectory)dest);
}
lock (dlist) { dlist.Remove(src.Name); }
});
if (Mode != Silversite.Services.Sync.Mode.Add) {
foreach (var dest in dlist) ddir.Delete(dest);
}
}
