public static void CompressZip( string directory, string archiveFile, Predicate <FileInfo> filter = null, CompressionLevel compressionLevel = CompressionLevel.Optimal, FileMode fileMode = FileMode.CreateNew) { Log.Information("Compressing content of {Directory} to {File} ...", directory, Path.GetFileName(archiveFile)); FileSystemTasks.EnsureExistingParentDirectory(archiveFile); var files = GetFiles(directory, filter); using (var fileStream = File.Open(archiveFile, fileMode, FileAccess.ReadWrite)) using (var zipArchive = new ZipArchive(fileStream, ZipArchiveMode.Create)) { // zipStream.SetLevel(1); foreach (var file in files) { var relativePath = PathConstruction.GetRelativePath(directory, file); var entryName = ZipEntry.CleanName(relativePath); zipArchive.CreateEntryFromFile(file, entryName, compressionLevel); } } }
public static string GetDirectoryHash(string directory, params string[] fileGlobPatterns) { ControlFlow.Assert(Directory.Exists(directory), $"Directory.Exists({directory})"); var files = (fileGlobPatterns.Length == 0 ? Directory.GetFiles(directory, "*", SearchOption.AllDirectories) : PathConstruction.GlobFiles(directory, fileGlobPatterns)) .OrderBy(x => x).ToList(); using (var md5 = MD5.Create()) { foreach (var file in files) { var relativePath = PathConstruction.GetRelativePath(directory, file); var unixNormalizedPath = PathConstruction.NormalizePath(relativePath, separator: '/'); var pathBytes = Encoding.UTF8.GetBytes(unixNormalizedPath); md5.TransformBlock(pathBytes, inputOffset: 0, inputCount: pathBytes.Length, outputBuffer: pathBytes, outputOffset: 0); var contentBytes = File.ReadAllBytes(file); md5.TransformBlock(contentBytes, inputOffset: 0, inputCount: contentBytes.Length, outputBuffer: contentBytes, outputOffset: 0); } md5.TransformFinalBlock(new byte[0], inputOffset: 0, inputCount: 0); return(BitConverter.ToString(md5.Hash).Replace("-", "").ToLower()); } }
private static void CompressTar( string directory, string archiveFile, Predicate <FileInfo> filter, FileMode fileMode, Func <Stream, Stream> outputStreamFactory) { Log.Information("Compressing content of {Directory} to {File} ...", directory, Path.GetFileName(archiveFile)); FileSystemTasks.EnsureExistingParentDirectory(archiveFile); var files = GetFiles(directory, filter); using var fileStream = File.Open(archiveFile, fileMode, FileAccess.ReadWrite); using var outputStream = outputStreamFactory(fileStream); using var tarArchive = TarArchive.CreateOutputTarArchive(outputStream); foreach (var file in files) { var entry = TarEntry.CreateEntryFromFile(file); var relativePath = PathConstruction.GetRelativePath(directory, file); entry.Name = PathConstruction.NormalizePath(relativePath, separator: '/'); tarArchive.WriteEntry(entry, recurse: false); } }
public static void FtpUploadDirectoryRecursively(string directory, string hostRoot) { Log.Information("Uploading directory {Directory} to {HostRoot} ...", directory, hostRoot); var files = PathConstruction.GlobFiles(directory, "**/*").ToList(); for (var index = 0; index < files.Count; index++) { var file = files[index]; var relativePath = PathConstruction.GetRelativePath(directory, file); var hostPath = $"{hostRoot}/{relativePath}"; FtpUploadFileInternal(file, hostPath, $"[{index + 1}/{files.Count}] "); } }
public static void CopyDirectoryRecursively( string source, string target, DirectoryExistsPolicy directoryPolicy = DirectoryExistsPolicy.Fail, FileExistsPolicy filePolicy = FileExistsPolicy.Fail, Func <DirectoryInfo, bool> excludeDirectory = null, Func <FileInfo, bool> excludeFile = null) { ControlFlow.Assert(Directory.Exists(source), $"Directory.Exists({source})"); ControlFlow.Assert(!PathConstruction.IsDescendantPath(source, target), $"Target directory '{target}' must not be in source directory '{source}'."); //ControlFlow.Assert(!Contains(source, target), $"Target '{target}' is not contained in source '{source}'."); Logger.Info($"Recursively copying from '{source}' to '{target}'..."); CopyRecursivelyInternal(source, target, directoryPolicy, filePolicy, excludeDirectory, excludeFile); }
public static void DeleteDirectory(string directory) { if (!Directory.Exists(directory)) { return; } if (PathConstruction.IsDescendantPath(EnvironmentInfo.BuildProjectDirectory, directory)) { Logger.Warn($"Skipping directory '{directory}' because it is contained in the build project directory..."); return; } Logger.Info($"Deleting directory '{directory}'..."); DeleteDirectoryInternal(directory); }
private static void CopyRecursivelyInternal( string source, string target, DirectoryExistsPolicy directoryPolicy, FileExistsPolicy filePolicy, [CanBeNull] Func <DirectoryInfo, bool> excludeDirectory, [CanBeNull] Func <FileInfo, bool> excludeFile) { if (excludeDirectory != null && excludeDirectory(new DirectoryInfo(source))) { return; } ControlFlow.Assert(!Directory.Exists(target) || directoryPolicy != DirectoryExistsPolicy.Fail, $"!Directory.Exists({target}) || directoryPolicy != DirectoryExistsPolicy.Fail"); string GetDestinationPath(string path) => Path.Combine(target, PathConstruction.GetRelativePath(source, path)); Directory.CreateDirectory(target); foreach (var sourceFile in Directory.GetFiles(source)) { if (excludeFile != null && excludeFile(new FileInfo(sourceFile))) { continue; } var targetFile = GetDestinationPath(sourceFile); if (!ShouldCopyFile(sourceFile, targetFile, filePolicy)) { continue; } //EnsureFileAttributes(sourceFile); File.Copy(sourceFile, targetFile, overwrite: true); } Directory.GetDirectories(source) .ForEach(x => CopyRecursivelyInternal( x, GetDestinationPath(x), directoryPolicy, filePolicy, excludeDirectory, excludeFile)); }
public static void UncompressZip(string archiveFile, string directory) { Log.Information("Uncompressing {File} to {Directory} ...", Path.GetFileName(archiveFile), directory); using var fileStream = File.OpenRead(archiveFile); using var zipFile = new ICSharpCode.SharpZipLib.Zip.ZipFile(fileStream); var entries = zipFile.Cast <ZipEntry>().Where(x => !x.IsDirectory); foreach (var entry in entries) { var file = PathConstruction.Combine(directory, entry.Name); FileSystemTasks.EnsureExistingParentDirectory(file); using var entryStream = zipFile.GetInputStream(entry); using var outputStream = File.Open(file, FileMode.Create); entryStream.CopyTo(outputStream); } }
private static void CopyRecursivelyInternal(string source, string target, FileExistsPolicy policy) { string GetDestinationPath(string path) => Path.Combine(target, PathConstruction.GetRelativePath(source, path)); Directory.CreateDirectory(target); Directory.GetDirectories(source).ForEach(x => CopyRecursivelyInternal(x, GetDestinationPath(x), policy)); foreach (var sourceFile in Directory.GetFiles(source)) { var targetFile = GetDestinationPath(sourceFile); if (!ShouldCopyFile(sourceFile, targetFile, policy)) { continue; } //EnsureFileAttributes(sourceFile); File.Copy(sourceFile, targetFile, overwrite: true); } }
public static void UncompressZip(string archiveFile, string directory) { using (var fileStream = File.OpenRead(archiveFile)) using (var zipFile = new ICSharpCode.SharpZipLib.Zip.ZipFile(fileStream)) { var entries = zipFile.Cast <ZipEntry>().Where(x => !x.IsDirectory); foreach (var entry in entries) { var file = PathConstruction.Combine(directory, entry.Name); FileSystemTasks.EnsureExistingParentDirectory(file); using (var entryStream = zipFile.GetInputStream(entry)) using (var outputStream = File.Open(file, FileMode.Create)) { entryStream.CopyTo(outputStream); } } } Logger.Info($"Uncompressed '{archiveFile}' to '{directory}'."); }
public static void CompressZip(string directory, string archiveFile, Predicate <FileInfo> filter, CompressionLevel compressionLevel) { FileSystemTasks.EnsureExistingParentDirectory(archiveFile); var files = GetFiles(directory, filter); using (var fileStream = File.Open(archiveFile, FileMode.CreateNew, FileAccess.ReadWrite)) using (var zipArchive = new ZipArchive(fileStream, ZipArchiveMode.Create)) { // zipStream.SetLevel(1); foreach (var file in files) { var relativePath = PathConstruction.GetRelativePath(directory, file); var entryName = ZipEntry.CleanName(relativePath); zipArchive.CreateEntryFromFile(file, entryName, compressionLevel); } } Logger.Info($"Compressed content of '{directory}' to '{Path.GetFileName(archiveFile)}'."); }
public override IEnumerable <(string, object)> GetValueSet(MemberInfo member, object instance) { return(GetGlobbedElements(member).Select(x => (PathConstruction.GetRelativePath(NukeBuild.RootDirectory, x), (object)x))); }