Work in progress

Author: witcher112

Assets/PatchKit Patcher/Scripts/AppData/Local/BaseWritableDirectory.cs

@@ -31,8 +31,9 @@ public string Path
 
         protected BaseWritableDirectory(string path)
         {
-            Assert.IsFalse(UsedPaths.Contains(path),
-                string.Format("You cannot create two instances of {0} pointing to the same path.", typeof(T)));
+            // This makes no sense.
+            //Assert.IsFalse(UsedPaths.Contains(path),
+            //    string.Format("You cannot create two instances of {0} pointing to the same path.", typeof(T)));
             Checks.ArgumentNotNullOrEmpty(path, "path");
 
             DebugLogger.LogConstructor();

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

@@ -35,20 +35,29 @@ private struct DownloadJob
 
         private readonly string _destinationFilePath;
 
-        private readonly RemoteResource _resource;
+        private readonly ResourceUrl[] _urls;
+
+        private readonly ChunksData _chunksData;
+
+        private readonly long _size;
 
         private bool _downloadHasBeenCalled;
 
         public event DownloadProgressChangedHandler DownloadProgressChanged;
 
-        public ChunkedHttpDownloader([NotNull] string destinationFilePath, RemoteResource resource)
+        public ChunkedHttpDownloader([NotNull] string destinationFilePath, [NotNull] ResourceUrl[] urls, ChunksData chunksData,
+            long size)
         {
             if (string.IsNullOrEmpty(destinationFilePath))
                 throw new ArgumentException("Value cannot be null or empty.", "destinationFilePath");
+            if (urls == null) throw new ArgumentNullException("urls");
+            if (size <= 0) throw new ArgumentOutOfRangeException("size");
 
             _logger = PatcherLogManager.DefaultLogger;
             _destinationFilePath = destinationFilePath;
-            _resource = resource;
+            _urls = urls;
+            _chunksData = chunksData;
+            _size = size;
         }
 
         private ChunkedFileStream OpenFileStream()
@@ -59,7 +68,7 @@ private ChunkedFileStream OpenFileStream()
                 Directory.CreateDirectory(parentDirectory);
             }
 
-            return new ChunkedFileStream(_destinationFilePath, _resource.Size, _resource.ChunksData,
+            return new ChunkedFileStream(_destinationFilePath, _size, _chunksData,
                 HashFunction, ChunkedFileStream.WorkFlags.PreservePreviousFile);
         }
 
@@ -68,17 +77,16 @@ public void Download(CancellationToken cancellationToken)
             try
             {
                 _logger.LogDebug("Downloading...");
-                _logger.LogTrace("resource.Size = " + _resource.Size);
-                for (int i = 0; i < _resource.ResourceUrls.Length; i++)
+                _logger.LogTrace("size = " + _size);
+                for (int i = 0; i < _urls.Length; i++)
                 {
-                    _logger.LogTrace("resource.ResourceUrls[" + i + "].Url = " + _resource.ResourceUrls[i].Url);
-                    _logger.LogTrace("resource.ResourceUrls[" + i + "].Country = " + _resource.ResourceUrls[i].Country);
-                    _logger.LogTrace(
-                        "resource.ResourceUrls[" + i + "].PartSize = " + _resource.ResourceUrls[i].PartSize);
+                    _logger.LogTrace("urls[" + i + "].Url = " + _urls[i].Url);
+                    _logger.LogTrace("urls[" + i + "].Country = " + _urls[i].Country);
+                    _logger.LogTrace("urls[" + i + "].PartSize = " + _urls[i].PartSize);
                 }
 
-                _logger.LogTrace("resource.ChunksData.ChunkSize = " + _resource.ChunksData.ChunkSize);
-                _logger.LogTrace("resource.ChunksData.Chunks.Length = " + _resource.ChunksData.Chunks.Length);
+                _logger.LogTrace("chunksData.ChunkSize = " + _chunksData.ChunkSize);
+                _logger.LogTrace("chunksData.Chunks.Length = " + _chunksData.Chunks.Length);
 
                 Assert.MethodCalledOnlyOnce(ref _downloadHasBeenCalled, "Download");
 
@@ -89,7 +97,7 @@ public void Download(CancellationToken cancellationToken)
                     do
                     {
                         bool success =
-                            _resource.ResourceUrls.Any(url => TryDownload(url, fileStream, cancellationToken));
+                            _urls.Any(url => TryDownload(url, fileStream, cancellationToken));
 
                         if (success)
                         {
@@ -202,11 +210,10 @@ private bool TryDownload(ResourceUrl url, ChunkedFileStream fileStream, Cancella
 
         private IEnumerable<DownloadJob> BuildDownloadJobQueue(ResourceUrl resourceUrl, long currentOffset)
         {
-            long totalSize = _resource.Size;
-            long partSize = resourceUrl.PartSize == 0 ? totalSize : resourceUrl.PartSize;
+            long partSize = resourceUrl.PartSize == 0 ? _size : resourceUrl.PartSize;
 
-            int partCount = (int) (totalSize / partSize);
-            partCount += totalSize % partSize != 0 ? 1 : 0;
+            int partCount = (int) (_size / partSize);
+            partCount += _size % partSize != 0 ? 1 : 0;
 
             for (int i = 0; i < partCount; i++)
             {

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

@@ -30,11 +30,10 @@ public sealed class HttpDownloader : IHttpDownloader
 
         public event DownloadProgressChangedHandler DownloadProgressChanged;
 
-        public HttpDownloader([NotNull] string destinationFilePath, [NotNull] string[] urls, long size)
+        public HttpDownloader([NotNull] string destinationFilePath, [NotNull] string[] urls)
         {
             if (destinationFilePath == null) throw new ArgumentNullException("destinationFilePath");
             if (urls == null) throw new ArgumentNullException("urls");
-            if (size <= 0) throw new ArgumentOutOfRangeException("size");
 
             _logger = PatcherLogManager.DefaultLogger;
             _destinationFilePath = destinationFilePath;

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

@@ -3,7 +3,7 @@
 
 namespace PatchKit.Unity.Patcher.AppData.Remote.Downloaders
 {
-    public interface ITorrentDownloader : IDisposable
+    public interface ITorrentDownloader
     {
         event DownloadProgressChangedHandler DownloadProgressChanged;
 

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

@@ -2,7 +2,12 @@
 using System.Diagnostics;
 using System.IO;
 using System.Text;
-using Newtonsoft.Json.Linq;
+using JetBrains.Annotations;
+using Newtonsoft.Json;
+using PatchKit.Logging;
+using PatchKit.Unity.Patcher.AppData.Remote.Downloaders.Torrents;
+using PatchKit.Unity.Patcher.AppData.Remote.Downloaders.Torrents.Protocol;
+using PatchKit.Unity.Patcher.Cancellation;
 using PatchKit.Unity.Patcher.Debug;
 
 namespace PatchKit.Unity.Patcher.AppData.Remote.Downloaders
@@ -11,9 +16,9 @@ namespace PatchKit.Unity.Patcher.AppData.Remote.Downloaders
     /// Provides an easy access for torrent client program.
     /// </summary>
     /// <seealso cref="System.IDisposable" />
-    public class TorrentClient : IDisposable
+    public sealed class TorrentClient : IDisposable
     {
-        private static readonly DebugLogger DebugLogger = new DebugLogger(typeof(TorrentClient));
+        private readonly ILogger _logger;
 
         private readonly ITorrentClientProcessStartInfoProvider _processStartInfoProvider;
 
@@ -27,62 +32,110 @@ public class TorrentClient : IDisposable
 
         public TorrentClient(ITorrentClientProcessStartInfoProvider processStartInfoProvider)
         {
-            DebugLogger.LogConstructor();
-
             _processStartInfoProvider = processStartInfoProvider;
 
+            _logger = PatcherLogManager.DefaultLogger;
             _process = StartProcess();
             _stdOutput = CreateStdOutputStream();
             _stdInput = CreateStdInputStream();
         }
 
-        /// <summary>
-        /// Executes the command and returns the result.
-        /// </summary>
-        public JToken ExecuteCommand(string command)
+        private static string ConvertPathForTorrentClient(string path)
+        {
+            return path.Replace("\\", "/").Replace(" ", "\\ ");
+        }
+
+        public TorrentClientStatus GetStatus(CancellationToken cancellationToken)
         {
-            Checks.ArgumentNotNull(command, "command");
+            try
+            {
+                _logger.LogDebug("Getting status...");
+
+                var result = ExecuteCommand<TorrentClientStatus>("status", cancellationToken);
 
-            DebugLogger.Log(string.Format("Executing command {0}", command));
+                _logger.LogDebug("Getting status finished.");
 
-            WriteCommand(command);
-            string resultStr = ReadCommandResult();
-            return ParseCommandResult(resultStr);
+                return result;
+            }
+            catch (Exception e)
+            {
+                _logger.LogError("Getting status failed.", e);
+                throw;
+            }
         }
 
-        private void WriteCommand(string command)
+        public void AddTorrent(string torrentFilePath, string downloadDirectoryPath,
+            CancellationToken cancellationToken)
         {
-            _stdInput.WriteLine(command);
-            _stdInput.Flush();
+            try
+            {
+                _logger.LogDebug(string.Format("Adding torrent from {0}...", torrentFilePath));
+                _logger.LogTrace("downloadDirectoryPath = " + downloadDirectoryPath);
+
+                var convertedTorrentFilePath = ConvertPathForTorrentClient(torrentFilePath);
+                var convertedDownloadDirectoryPath = ConvertPathForTorrentClient(downloadDirectoryPath);
+
+                _logger.LogTrace("convertedTorrentFilePath = " + convertedTorrentFilePath);
+                _logger.LogTrace("convertedDownloadDirectoryPath = " + convertedDownloadDirectoryPath);
+
+                var command = string.Format("add-torrent {0} {1}", convertedTorrentFilePath,
+                    convertedDownloadDirectoryPath);
+
+                var result = ExecuteCommand<TorrentClientMessage>(command, cancellationToken);
+
+                _logger.LogTrace("result.Message = " + result.Message);
+                _logger.LogTrace("result.Status = " + result.Status);
+
+                if (result.Status != "ok")
+                {
+                    throw new AddTorrentFailureException(
+                        string.Format("Invalid add-torrent status: {0}", result.Status));
+                }
+
+                _logger.LogDebug("Adding torrent finished.");
+            }
+            catch (Exception e)
+            {
+                _logger.LogError("Adding torrent failed.", e);
+                throw;
+            }
         }
 
-        private JToken ParseCommandResult(string resultStr)
+        private TResult ExecuteCommand<TResult>([NotNull] string command, CancellationToken cancellationToken)
         {
-            return JToken.Parse(resultStr);
+            if (command == null) throw new ArgumentNullException("command");
+
+            _logger.LogDebug(string.Format("Executing command {0}", command));
+
+            _stdInput.WriteLine(command);
+            _stdInput.Flush();
+
+            string resultStr = ReadCommandResult(cancellationToken);
+
+            _logger.LogDebug("Command execution finished. Parsing result...");
+            _logger.LogTrace("result = " + resultStr);
+
+            var result = JsonConvert.DeserializeObject<TResult>(resultStr);
+
+            _logger.LogDebug("Parsing finished.");
+
+            return result;
         }
 
-        private string ReadCommandResult()
+        private string ReadCommandResult(CancellationToken cancellationToken)
         {
             var str = new StringBuilder();
 
             while (!str.ToString().EndsWith("#=end"))
             {
-                ThrowIfProcessExited();
+                cancellationToken.ThrowIfCancellationRequested();
 
-                str.Append((char)_stdOutput.Read());
+                str.Append((char) _stdOutput.Read());
             }
 
             return str.ToString().Substring(0, str.Length - 5);
         }
 
-        private void ThrowIfProcessExited()
-        {
-            if (_process.HasExited)
-            {
-                throw new TorrentClientException("torrent-client process has exited.");
-            }
-        }
-
         private StreamReader CreateStdOutputStream()
         {
             return new StreamReader(_process.StandardOutput.BaseStream, CreateStdEncoding());
@@ -93,16 +146,22 @@ private StreamWriter CreateStdInputStream()
             return new StreamWriter(_process.StandardInput.BaseStream, CreateStdEncoding());
         }
 
-        private Encoding CreateStdEncoding()
+        private static Encoding CreateStdEncoding()
         {
             return new UTF8Encoding(false);
         }
 
         private Process StartProcess()
         {
             var processStartInfo = _processStartInfoProvider.GetProcessStartInfo();
+            _logger.LogTrace("processStartInfo.FileName" + processStartInfo.FileName);
+            _logger.LogTrace("processStartInfo.Arguments" + processStartInfo.Arguments);
+
+            _logger.LogDebug("Starting torrent-client process...");
+            var process = Process.Start(processStartInfo);
+            _logger.LogDebug("torrent-client process started.");
 
-            return Process.Start(processStartInfo);
+            return process;
         }
 
         public void Dispose()
@@ -116,38 +175,54 @@ 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)
             {
                 _stdOutput.Dispose();
                 _stdInput.Dispose();
 
-                if (!_process.HasExited)
+                try
                 {
-                    try
+                    _logger.LogDebug("Killing torrent-client process...");
+
+                    if (!_process.HasExited)
                     {
-                        DebugLogger.Log("Killing torrent client process...");
+                        _logger.LogDebug("Sending kill request and waiting one second...");
                         _process.Kill();
                         _process.WaitForExit(1000);
-                        DebugLogger.Log("Torrent client process has been killed.");
+                        if (_process.HasExited)
+                        {
+                            _logger.LogDebug("torrent-client process killed.");
+                        }
+                        else
+                        {
+                            _logger.LogWarning(
+                                "torrent-client process hasn't been killed. Ignoring in order to not freeze application execution.");
+                        }
                     }
-                    catch (Exception exception)
+                    else
                     {
-                        DebugLogger.LogWarning("Killing torrent client process has failed: an exception has occured.");
-                        DebugLogger.LogException(exception);
+                        _logger.LogDebug("torrent-client process is already killed.");
                     }
                 }
+                catch (Exception e)
+                {
+                    _logger.LogError("Killing torrent-client process failed.", e);
+                    throw;
+                }
+                finally
+                {
+                    _process.Dispose();
+                }
             }
 
             _disposed = true;
         }
     }
-}
+}