Major refactor in ChunkedFileStream

Author: witcher112

Assets/PatchKit Patcher/Scripts/AppData/Remote/Downloaders/ChunkedFileStream.cs

@@ -1,6 +1,8 @@
 using System;
 using System.IO;
 using System.Linq;
+using JetBrains.Annotations;
+using PatchKit.Logging;
 using PatchKit.Unity.Patcher.Debug;
 
 namespace PatchKit.Unity.Patcher.AppData.Remote.Downloaders
@@ -12,20 +14,20 @@ namespace PatchKit.Unity.Patcher.AppData.Remote.Downloaders
     /// has to be predefined.
     /// 
     /// Usage:
-    /// Use Write() function as usuall to write bytes. As soon as you will get false stop copying
+    /// Use Write() function as usuall to write bytes. As soon as you will catch InvalidChunkDataException stop copying
     /// procedure and restart it from next byte after VerifiedLength. If you will try to write
     /// bytes above the limit, you will get ArgumentOutOfRangeException.
     /// </summary>
-    public class ChunkedFileStream : IDisposable
+    public sealed class ChunkedFileStream : IDisposable
     {
         [Flags]
         public enum WorkFlags
         {
             None = 0,
             PreservePreviousFile = 1
         }
-        
-        private static readonly DebugLogger DebugLogger = new DebugLogger(typeof(ChunkedFileStream));
+
+        private readonly ILogger _logger;
 
         public delegate byte[] HashFunction(byte[] buffer, int offset, int length);
 
@@ -36,7 +38,7 @@ public enum WorkFlags
         private readonly byte[] _buffer;
         private int _bufferPos;
         private int _chunkIndex;
-        private readonly FileStream _fileStream;
+        private FileStream _fileStream;
 
         private bool _disposed;
 
@@ -60,58 +62,85 @@ public long Length
             get { return _fileSize; }
         }
 
-        public ChunkedFileStream(string path, long fileSize, ChunksData chunksData, HashFunction hashFunction,
+        public ChunkedFileStream([NotNull] string path, long fileSize, ChunksData chunksData,
+            [NotNull] HashFunction hashFunction,
             WorkFlags workFlags = WorkFlags.None)
         {
-            Checks.ArgumentNotNullOrEmpty(path, "path");
-            Checks.ArgumentMoreThanZero(fileSize, "fileSize");
-            Checks.ArgumentNotNull(hashFunction, "hashFunction");
-
-            DebugLogger.LogConstructor();
-            DebugLogger.LogVariable(path, "path");
-            DebugLogger.LogVariable(fileSize, "fileSize");
+            if (path == null) throw new ArgumentNullException("path");
+            if (fileSize <= 0) throw new ArgumentOutOfRangeException("fileSize");
+            if (hashFunction == null) throw new ArgumentNullException("hashFunction");
 
+            _logger = PatcherLogManager.DefaultLogger;
             _fileSize = fileSize;
             _chunksData = chunksData;
             _hashFunction = hashFunction;
 
             _buffer = new byte[_chunksData.ChunkSize];
 
-            if ((workFlags | WorkFlags.PreservePreviousFile) != 0)
+            _logger.LogTrace("path = " + path);
+            _logger.LogTrace("fileSize = " + fileSize);
+            _logger.LogTrace("chunksData.ChunkSize = " + chunksData.ChunkSize);
+
+            bool preservePreviousFile = (workFlags | WorkFlags.PreservePreviousFile) != 0;
+
+            _logger.LogTrace("preservePreviousFile = " + preservePreviousFile);
+
+            if (preservePreviousFile)
             {
                 // Often you may want to continue downloading of a file if this exists
                 // It tries to open a file and re-download it from the verified position.
                 // It does not check the hash of the file. It trusts that the file is already valid up to that point.
                 // Because the only way to download the file should be using Chunked Downloader.
-                
+
+                _logger.LogDebug("Opening file stream...");
                 _fileStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
                 _fileStream.Seek(0, SeekOrigin.End); // seek and stay at the end, so we can append
                 long currentFileSize = _fileStream.Position;
+                _logger.LogDebug("File stream opened.");
+                _logger.LogTrace("currentFileSize = " + currentFileSize);
+
+                _logger.LogDebug("Checking whether stream can append to current file...");
 
+
+                if (currentFileSize == 0)
+                {
+                    _logger.LogDebug("File is new. Append is not possible.");
+                }
                 // Let's make sure that file size is a multiply of chunk size.
                 // If not, something is wrong with the file.
-                if (currentFileSize % chunksData.ChunkSize == 0)
+                else if (currentFileSize % chunksData.ChunkSize == 0)
                 {
                     _chunkIndex = (int) (currentFileSize / chunksData.ChunkSize);
+                    _logger.LogDebug(string.Format("Append is possible - starting from {0} chunk index.", _chunkIndex));
                 }
                 else
                 {
-                    DebugLogger.LogWarningFormat(
-                        "File {0} size {1} is not a multiply of chunk size: {2}. Will recreate it.", path,
-                        currentFileSize, chunksData.ChunkSize);
-                    
+                    _logger.LogDebug(string.Format(
+                        "File size {0} is not a multiply of chunk size: {1}. Append is not possible - recreating file.",
+                        currentFileSize,
+                        chunksData.ChunkSize));
+
+                    _logger.LogDebug("Closing previous file stream...");
                     _fileStream.Close();
                     _fileStream.Dispose();
-                    
-                    _fileStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
+                    _logger.LogDebug("Previous file stream closed.");
+
+                    OpenNewFileStream(path);
                 }
             }
             else
             {
-                _fileStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
+                OpenNewFileStream(path);
             }
         }
 
+        private void OpenNewFileStream(string path)
+        {
+            _logger.LogDebug("Opening new file stream...");
+            _fileStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
+            _logger.LogDebug("New file stream opened.");
+        }
+
         /// <summary>
         /// Writes buffer into the file. If false is returned, stop file transfer and resume it
         /// starting from VerifiedLength + 1 byte.
@@ -120,10 +149,11 @@ public ChunkedFileStream(string path, long fileSize, ChunksData chunksData, Hash
         /// <param name="offset"></param>
         /// <param name="count"></param>
         /// <returns></returns>
-        public void Write(byte[] buffer, int offset, int count)
+        public void Write([NotNull] byte[] buffer, int offset, int count)
         {
-            Checks.ArgumentNotNull(buffer, "buffer");
-            // TODO: Rest of assertions
+            if (buffer == null) throw new ArgumentNullException("buffer");
+            if (offset < 0) throw new ArgumentOutOfRangeException("offset");
+            if (count < 0) throw new ArgumentOutOfRangeException("count");
 
             do
             {
@@ -133,7 +163,7 @@ public void Write(byte[] buffer, int offset, int count)
                         "Cannot write bytes over the file size: " + _fileSize);
                 }
 
-                int copyNum = (int)Math.Min(Math.Min(count, _chunksData.ChunkSize - _bufferPos), RemainingLength);
+                int copyNum = (int) Math.Min(Math.Min(count, _chunksData.ChunkSize - _bufferPos), RemainingLength);
                 Array.Copy(buffer, offset, _buffer, _bufferPos, copyNum);
 
                 count -= copyNum;
@@ -151,7 +181,6 @@ public void Write(byte[] buffer, int offset, int count)
                         DiscardBuffer();
                         throw new InvalidChunkDataException("Invalid chunk data.");
                     }
-
                 }
             } while (count > 0);
         }
@@ -163,15 +192,15 @@ private bool ChunkFullyInBuffer()
 
         private bool BufferedChunkValid()
         {
-            byte[] bufferHash = _hashFunction(_buffer, 0, (int)Math.Min(_chunksData.ChunkSize, RemainingLength));
+            byte[] bufferHash = _hashFunction(_buffer, 0, (int) Math.Min(_chunksData.ChunkSize, RemainingLength));
             byte[] chunkHash = _chunksData.Chunks[_chunkIndex].Hash;
 
             return bufferHash.SequenceEqual(chunkHash);
         }
 
         private void FlushBuffer()
         {
-            _fileStream.Write(_buffer, 0, (int)Math.Min(_chunksData.ChunkSize, RemainingLength));
+            _fileStream.Write(_buffer, 0, (int) Math.Min(_chunksData.ChunkSize, RemainingLength));
             _bufferPos = 0;
             _chunkIndex++;
         }
@@ -192,21 +221,19 @@ public void Dispose()
             Dispose(false);
         }
 
-        protected virtual void Dispose(bool disposing)
+        private void Dispose(bool disposing)
         {
-            if(_disposed)
+            if (_disposed)
             {
                 return;
             }
 
-            DebugLogger.LogDispose();
-
-            if(disposing)
+            if (disposing)
             {
                 _fileStream.Dispose();
             }
 
             _disposed = true;
         }
     }
-}
+}