private async Task CompressSmallFile(FileHeader header)
{
header.NumberOfChunks = 1;
await using var readStream = ArchiveStream.OpenRead(header.FullPath);
var chunkCompressor = GetChunkCompressor();
var chunk = await readStream.ReadBytesAsync(header.FileSize);
var compressedChunk = await chunkCompressor(chunk, header.CompressionType);
var chunkHeader = new ChunkHeader()
{
Size = compressedChunk.Length,
SerialNumber = 0
};
header.Chunks.Add(chunkHeader);
using (await _asyncLock.LockAsync())
{
header.Position = _outputStream.Position + header.SizeOf;
await _outputStream.WriteFileHeaderAsync(header);
await _outputStream.WriteAsync(compressedChunk);
}
_archiveProgress.Report(header.RelativePath, chunk.Length, chunkHeader.SerialNumber, header.NumberOfChunks);
}
public async Task ExtractAsync(string inputPath, string outputPath)
{
await using var stream = ArchiveStream.OpenRead(inputPath);
var directoryHeaders = (await stream.ReadAllDirectoriesAsync(outputPath)).ToList();
var fileHeaders = (await stream.ReadAllFileHeadersAsync(outputPath)).ToList();
directoryHeaders.AsParallel().ForAll(x =>
{
if (!string.IsNullOrEmpty(x.FullPath) && !Directory.Exists(x.FullPath))
{
Directory.CreateDirectory(x.FullPath);
}
});
try
{
await Decompressor.DecompressAsync(stream, fileHeaders);
}
catch (Exception ex)
{
await DeleteFiles(fileHeaders);
await DeleteDirectories(directoryHeaders);
throw new ArchiveException(ex.Message);
}
}
public async Task <List <FileHeader> > GetFilesAsync(string path)
{
await using var stream = ArchiveStream.OpenRead(path);
var fileHeaders = await stream.ReadAllFileHeadersAsync(path);
return(fileHeaders.ToList());
}
public async Task <bool> IsEncryptedAsync(string path)
{
await using var stream = ArchiveStream.OpenRead(path);
var archiveInfo = await stream.ReadArchiveInfoAsync();
return(archiveInfo.IsEncrypted);
}
public async Task <ArchiveInfo> GetArchiveInfoAsync(string path)
{
await using var stream = ArchiveStream.OpenRead(path);
var archiveInfo = await stream.ReadArchiveInfoAsync();
return(archiveInfo);
}
public async Task <List <DirectoryHeader> > GetDirectoriesAsync(string path)
{
await using var stream = ArchiveStream.OpenRead(path);
var directoryHeaders = await stream.ReadAllDirectoriesAsync(path);
return(directoryHeaders.ToList());
}
public async Task <bool> IsArchiveAsync(string path)
{
await using var stream = ArchiveStream.OpenRead(path);
try
{
await stream.ReadArchiveInfoAsync();
return(true);
}
catch
{
return(false);
}
}
private async Task CompressBigFileAsync(FileHeader header)
{
await using var readStream = ArchiveStream.OpenRead(header.FullPath, Settings.ThreadsCount);
var chunkCompressor = GetChunkCompressor();
header.NumberOfChunks = readStream.GetChunksCount();
_outputStream.Seek(header.SizeOf, SeekOrigin.Current);
header.Position = _outputStream.Position;
var chunkSerialNumber = 0;
await foreach (var chunks in readStream.ReadFileInChunksAsync(Settings.ChunkSize))
{
var tasks = chunks.Select(x => chunkCompressor(x, header.CompressionType));
var chunksSizes = chunks.Select(x => x.Length).ToArray();
var compressedChunks = await Task.WhenAll(tasks);
for (var i = 0; i < compressedChunks.Length; i++)
{
var chunkHeader = new ChunkHeader()
{
Size = compressedChunks[i].Length,
SerialNumber = chunkSerialNumber++,
};
header.Chunks.Add(chunkHeader);
await _outputStream.WriteAsync(compressedChunks[i]);
_archiveProgress.Report(header.RelativePath, chunksSizes[i], chunkHeader.SerialNumber,
header.NumberOfChunks);
}
var currentPosition = _outputStream.Position;
_outputStream.Position = header.Position - header.SizeOf;
await _outputStream.WriteFileHeaderAsync(header);
_outputStream.Position = currentPosition;
}
}