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)));
}
