private static string ExtensionFromAlgo(CompressionAlgo algo, bool crypted)
{
switch (algo)
{
case CompressionAlgo.Lz4 when crypted:
return(".tarlz4aes");
case CompressionAlgo.Lz4:
return(".tarlz4");
case CompressionAlgo.Brotli when crypted:
return(".tarbraes");
case CompressionAlgo.Brotli:
return(".tarbr");
case CompressionAlgo.Zstd when crypted:
return(".tarzstdaes");
case CompressionAlgo.Zstd:
return(".tarzstd");
default:
throw new ArgumentOutOfRangeException(nameof(algo), algo, null);
}
}
public CompressOption GetTccCompressOption(string targetFolder, CompressionAlgo algo)
{
string src;
if (Files != null)
{
src = String.Join(" ", Files.Select(i => i.FullName));
}
else if (Directories != null)
{
src = String.Join(" ", Directories.Select(i => i.FullName));
}
else
{
throw new MissingMemberException();
}
Target = targetFolder;
var compressOption = new CompressOption
{
Algo = algo,
BlockMode = BlockMode.Individual,
SourceDirOrFile = src,
DestinationDir = Target,
Threads = Environment.ProcessorCount
};
return(compressOption);
}
public static void UpdateTarget(
string what,
string newWhere,
bool newCompressed,
CompressionAlgo newAlgo,
CompressionLevel newLevel,
DateTime newStart,
TimeSpan newInterval)
{
BackupTarget target;
if ((target = GetTarget(what)) == null)
throw new ArgumentException(nameof(what));
// make sure there aren't any minutes or seconds
newInterval = new TimeSpan(newInterval.Days, newInterval.Hours, 0, 0);
target.Where = newWhere;
target.Compressed = newCompressed;
target.Algo = newAlgo;
target.Level = newLevel;
target.Interval = newInterval;
target.Start = newStart;
target.CalculateNextBackup(true);
var index = targets.IndexOf(target);
targets.RemoveAt(index);
targets.Insert(index, target);
SaveTargets();
}
private static IEnumerable <int> UserDefinedRatios(string ratios, CompressionAlgo algo)
{
foreach (var r in ratios.Split(','))
{
if (int.TryParse(r, out int ratio) && ratio > 0 && ratio <= MaxRatio(algo))
{
yield return(ratio);
}
}
}
public void AlgoCommands(string command, CompressionAlgo algo)
{
var commandBlocks = command.Split(" ", StringSplitOptions.RemoveEmptyEntries);
var parsed = commandBlocks.ParseCommandLine();
Assert.Equal(0, parsed.ReturnCode);
Assert.IsType <CompressOption>(parsed.Option);
Assert.Equal(algo, ((CompressOption)parsed.Option).Algo);
Assert.Equal(3, ((CompressOption)parsed.Option).CompressionRatio);
}
private async Task <OperationSummary> Compress(PasswordMode passwordMode, CompressionAlgo algo,
string compressedFolder, string keysFolder, TestData data)
{
CompressOption compressOption = data.GetTccCompressOption(compressedFolder, algo);
compressOption.PasswordOption = await _benchmarkOptionHelper.GenerateCompressPasswordOption(passwordMode, keysFolder);
var resultCompress = await _tarCompressCrypt.Compress(compressOption);
return(resultCompress);
}
private static int MaxRatio(CompressionAlgo algo)
{
switch (algo)
{
case CompressionAlgo.Lz4:
return(9);
case CompressionAlgo.Brotli:
return(9);
case CompressionAlgo.Zstd:
return(19);
default:
throw new ArgumentOutOfRangeException(nameof(algo));
}
}
private static bool ShouldTestAlgo(BenchmarkOption benchmarkOption, CompressionAlgo algo)
{
switch (algo)
{
case CompressionAlgo.Lz4:
return((benchmarkOption.Algorithm & BenchmarkCompressionAlgo.Lz4) == BenchmarkCompressionAlgo.Lz4);
case CompressionAlgo.Brotli:
return((benchmarkOption.Algorithm & BenchmarkCompressionAlgo.Brotli) == BenchmarkCompressionAlgo.Brotli);
case CompressionAlgo.Zstd:
return((benchmarkOption.Algorithm & BenchmarkCompressionAlgo.Zstd) == BenchmarkCompressionAlgo.Zstd);
default:
throw new ArgumentOutOfRangeException(nameof(algo), algo, "Unknown algo");
}
}
public BackupTarget(
string what,
string where,
bool compressed,
CompressionAlgo algo,
CompressionLevel level,
TimeSpan interval,
DateTime start)
{
What = what;
Where = where;
Compressed = compressed;
Algo = algo;
Level = level;
Interval = interval;
Start = start;
NextBackup = start;
CalculateNextBackup();
}
public async Task CompressDecompress(PasswordMode mode, CompressionAlgo algo)
{
await _externalDependencies.EnsureAllDependenciesPresent();
string toCompressFolder = TestFileHelper.NewFolder();
string compressedFolder = TestFileHelper.NewFolder();
string decompressedFolder = TestFileHelper.NewFolder();
string keysFolder = TestFileHelper.NewFolder();
var data = await TestData.CreateFiles(1, 1024, toCompressFolder);
OperationSummary resultCompress = await Compress(mode, algo, compressedFolder, keysFolder, data);
resultCompress.ThrowOnError();
Assert.True(resultCompress.IsSuccess);
Assert.NotEmpty(resultCompress.OperationBlocks.Select(i => i.Block));
Assert.NotEmpty(resultCompress.OperationBlocks.Select(i => i.CommandResult));
var decomp = new TestData {
Directories = new List <DirectoryInfo> {
new DirectoryInfo(compressedFolder)
}
};
OperationSummary resultDecompress = await Decompress(mode, decompressedFolder, keysFolder, decomp);
resultDecompress.ThrowOnError();
Assert.True(resultDecompress.IsSuccess);
Assert.NotEmpty(resultDecompress.OperationBlocks.Select(i => i.Block));
Assert.NotEmpty(resultDecompress.OperationBlocks.Select(i => i.CommandResult));
FileInfo src = new DirectoryInfo(toCompressFolder).EnumerateFiles().FirstOrDefault();
FileInfo dst = new DirectoryInfo(decompressedFolder).EnumerateFiles().FirstOrDefault();
Assert.True(TestFileHelper.FilesAreEqual(src, dst));
}
public static void AddTarget(
string what,
string where,
bool compressed,
CompressionAlgo algo,
CompressionLevel level,
DateTime start,
TimeSpan interval)
{
if (HasTarget(what))
throw new ArgumentException(nameof(what));
// make sure there aren't any minutes or seconds
interval = new TimeSpan(interval.Days, interval.Hours, 0, 0);
var nextBackup = start;
var now = DateTime.Now;
while (nextBackup < now)
nextBackup = nextBackup.Add(interval);
targets.Add(new BackupTarget(what, where, compressed, algo, level, interval, start));
SaveTargets();
}
private static IEnumerable <int> GetBenchmarkRatios(BenchmarkOption benchmarkOption, CompressionAlgo algo)
{
if (String.IsNullOrEmpty(benchmarkOption.Ratios))
{
return(Enumerable.Range(1, MaxRatio(algo)));
}
var ratios = UserDefinedRatios(benchmarkOption.Ratios, algo).ToList();
return(Enumerable.Range(ratios.Min(), ratios.Max() - ratios.Min() + 1));
}
private static Block GenerateDecompressBlock(FileInfo sourceFile, DirectoryInfo targetDirectory, CompressionAlgo algo)
{
return(new Block
{
OperationFolder = targetDirectory.FullName,
Source = sourceFile.FullName,
DestinationFolder = targetDirectory.FullName,
ArchiveName = sourceFile.FullName,
Algo = algo
});
}
public static long Decompress(Stream from, Stream to,
CompressionAlgo algo, Action<int, object> reportProgress) => decompressors[algo](from, to, reportProgress);
public static long Compress(Stream from, Stream to, CompressionAlgo algo,
CompressionLevel level, Action<int, object> reportProgress) => compressors[algo](from, to, level, reportProgress);
public static bool TestCompression(Stream stream, CompressionAlgo algo,
CompressionLevel level, Action<int, object> reportProgess, out long resultLength)
{
using (var temp = GetTempFileStream())
return stream.Length > (resultLength = Compress(stream, temp, algo, level, reportProgess));
}
