public void FactoryWillCreateChunksQueueObj()
{
IChunksReader chunksReader = _taskFactory.CreateChunksReader(It.IsAny <int>(), It.IsAny <ISourceReader>(),
It.IsAny <IGZipCompressor>(), It.IsAny <IWriterTask>(), It.IsAny <IErrorLogs>());
Assert.IsInstanceOf <ChunksReader>(chunksReader);
}
/// <summary>
/// Perform file compression or decompression action
/// </summary>
/// <param name="actionType">Action name. Possible values: compress, decompress</param>
/// <param name="workersCount">Number of threads</param>
/// <param name="chunkSize">Chunk size in bytes</param>
/// <param name="errors">Exceptions</param>
/// <returns>Operation result</returns>
public bool Execute(string actionType, int workersCount, int chunkSize, out List <Exception> errors)
{
ChunksInfo chunkInfos = _fileSplitterFactory.Create(actionType).GetChunks(_inFile, chunkSize);
using (IWriterTask fileWriterTask = _taskFactory.CreatWriterTask(chunkInfos.ChunksCount, _chunkWriter, _errorLogs))
using (IChunksReader chunksReader = _taskFactory.CreateChunksReader(workersCount, _sourceReader,
_compressorFactory.Create(actionType), fileWriterTask, _errorLogs))
{
foreach (ChunkReadInfo chunkInfo in chunkInfos.Chunks)
{
chunksReader.EnqueueChunk(new ChunkReadInfo(chunkInfo.Id, chunkInfo.Offset, chunkInfo.BytesCount));
}
while (true)
{
if (!_errorLogs.IsErrorExist(out List <Exception> exceptions))
{
if (!IsActiveOp(chunksReader, fileWriterTask))
{
return(!_errorLogs.IsErrorExist(out errors));
}
continue;
}
errors = exceptions;
return(false);
}
}
}
public Task Start(TaskParameters parameters)
{
_logger.Write($"Starting task with parameters: {parameters}");
var cancellationTokenSource = new CancellationTokenSource();
var inputFile = File.OpenRead(parameters.SourceFullPath);
var outputFile = File.Create(parameters.DestinationFullPath);
var inputPipe = new Pipe(parameters.MaxElementsInPipe);
var outputPipe = new Pipe(parameters.MaxElementsInPipe);
var expectedChunksCount = GetExpectedChunksCount(parameters, inputFile, outputFile);
var writer = new ChunksWriter(outputPipe, _logger);
IChunksReader reader = null;
IEnumerable <IChunksProcessor> processors = null;
switch (parameters.Mode)
{
case ProcessorMode.Compress:
reader = new ChunksReader(inputPipe, parameters.ChunkSize, _logger);
processors = Enumerable.Range(0, parameters.ParallelismDegree).Select(
_ => new ChunksCompressor(inputPipe, outputPipe, _logger));
break;
case ProcessorMode.Decompress:
reader = new CompressedChunksReader(inputPipe, parameters.ChunkSize, _logger);
processors = Enumerable.Range(0, parameters.ParallelismDegree).Select(
_ => new ChunksDecompressor(inputPipe, outputPipe, _logger));
break;
}
var actions = new Action[]
{
() =>
{
(reader ?? throw new ArgumentNullException()).ReadFromStream(inputFile, cancellationTokenSource.Token);
inputFile.Close();
},
() =>
{
writer.WriteToStream(
outputFile,
cancellationTokenSource.Token,
expectedChunksCount,
writeChunksLengths: parameters.Mode == ProcessorMode.Compress);
outputFile.Close();
},
}.Concat((processors ?? throw new ArgumentNullException())
/// <summary>
/// Is operation active
/// </summary>
/// <returns>Result of checking</returns>
public bool IsActiveOp(IChunksReader chunksReader, IWriterTask writerTask)
{
return(chunksReader.IsActive() || writerTask.IsActive());
}
