Merge pull request #140 from patchkit-net/dev/v3.16.x.x

Release 3.16.0.0

Author: witcher112

Assets/PatchKit Patcher/Scripts/Api/ApiConnection.cs

@@ -131,7 +131,7 @@ private bool TryGetResponse(ApiConnectionServer server, Request request, ServerT
                 var httpRequest = new HttpGetRequest
                 {
                     Address = uri,
-                    Timeout = RequestTimeoutCalculator.Timeout
+                    Timeout = 30000
                 };
 
                 Logger.LogTrace("timeout = " + httpRequest.Timeout + "ms");

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

@@ -9,6 +9,7 @@
 using PatchKit.Unity.Patcher.AppData.FileSystem;
 using PatchKit.Unity.Patcher.Cancellation;
 using PatchKit.Unity.Patcher.Debug;
+using PatchKit.Unity.Utilities;
 
 namespace PatchKit.Unity.Patcher.AppData.Local
 {
@@ -188,7 +189,7 @@ private void SaveData()
             _logger.LogDebug(string.Format("Saving data to {0}", _filePath));
 
             CreateDataDir();
-            File.WriteAllText(_filePath, JsonConvert.SerializeObject(_data, Formatting.None));
+            Files.WriteAllText(_filePath, JsonConvert.SerializeObject(_data, Formatting.None));
 
             _logger.LogDebug("Data saved.");
         }

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

@@ -7,18 +7,35 @@
 using PatchKit.Unity.Patcher.Cancellation;
 using PatchKit.Unity.Patcher.Debug;
 using PatchKit.Unity.Utilities;
+using UnityEngine.Networking;
 
 namespace PatchKit.Unity.Patcher.AppData.Remote.Downloaders
 {
     public sealed class BaseHttpDownloader : IBaseHttpDownloader
     {
+        private class Handler : DownloadHandlerScript
+        {
+            private Action<byte[], int> _receiveData;
+
+            public Handler(Action<byte[], int> receiveData)
+            {
+                _receiveData = receiveData;
+            }
+
+            protected override bool ReceiveData(byte[] data, int dataLength)
+            {
+                _receiveData(data, dataLength);
+
+                return true;
+            }
+        }
+
         private readonly ILogger _logger;
 
         private static readonly int BufferSize = 5 * (int) Units.MB;
 
         private readonly string _url;
         private readonly int _timeout;
-        private readonly IHttpClient _httpClient;
 
         private readonly byte[] _buffer;
 
@@ -28,21 +45,19 @@ public sealed class BaseHttpDownloader : IBaseHttpDownloader
         public event DataAvailableHandler DataAvailable;
 
         public BaseHttpDownloader(string url, int timeout) :
-            this(url, timeout, new DefaultHttpClient(), PatcherLogManager.DefaultLogger)
+            this(url, timeout, PatcherLogManager.DefaultLogger)
         {
         }
 
-        public BaseHttpDownloader([NotNull] string url, int timeout, [NotNull] IHttpClient httpClient,
+        public BaseHttpDownloader([NotNull] string url, int timeout,
             [NotNull] ILogger logger)
         {
             if (string.IsNullOrEmpty(url)) throw new ArgumentException("Value cannot be null or empty.", "url");
             if (timeout <= 0) throw new ArgumentOutOfRangeException("timeout");
-            if (httpClient == null) throw new ArgumentNullException("httpClient");
             if (logger == null) throw new ArgumentNullException("logger");
 
             _url = url;
             _timeout = timeout;
-            _httpClient = httpClient;
             _logger = logger;
 
             _buffer = new byte[BufferSize];
@@ -76,42 +91,121 @@ public void Download(CancellationToken cancellationToken)
 
                 Assert.MethodCalledOnlyOnce(ref _downloadHasBeenCalled, "Download");
 
-                var request = new HttpGetRequest
-                {
-                    Address = new Uri(_url),
-                    Range = _bytesRange,
-                    Timeout = _timeout,
-                    ReadWriteTimeout = _timeout,
-                };
+                UnityWebRequest request = null;
+                Exception dataAvailableException = null;
+                DateTime lastDataAvailable = DateTime.Now;
 
-                using (var response = _httpClient.Get(request))
+                UnityDispatcher.Invoke(() => 
                 {
-                    cancellationToken.ThrowIfCancellationRequested();
+                    request = new UnityWebRequest();
+                    request.uri = new Uri(_url);
+                    request.timeout = 0;
 
-                    _logger.LogDebug("Received response from server.");
-                    _logger.LogTrace("statusCode = " + response.StatusCode);
-
-                    if (Is2XXStatus(response.StatusCode))
+                    if (_bytesRange.HasValue)
                     {
-                        _logger.LogDebug("Successful response. Reading response stream...");
+                        var bytesRangeEndText = 
+                            _bytesRange.Value.End >= 0L ? _bytesRange.Value.End.ToString() : string.Empty;
 
-                        //TODO: Could response.ContentStream be null? Need to check it.
+                        request.SetRequestHeader(
+                            "Range", 
+                            "bytes=" + _bytesRange.Value.Start + "-" + bytesRangeEndText);
+                    }
 
-                        ReadResponseStream(response.ContentStream, cancellationToken);
+                    request.downloadHandler = new Handler((data, length) => {
+
+                        lastDataAvailable = DateTime.Now;
+
+                        if (DataAvailable != null && dataAvailableException == null)
+                        {
+                            try
+                            {
+                                DataAvailable.Invoke(data, length);
+                            }
+                            catch (Exception e)
+                            {
+                                dataAvailableException = e;
+                            }
+                        }
+                    });
+                }).WaitOne();
+
+                using (request)
+                {
+                    using(request.downloadHandler)
+                    {
+                        UnityWebRequestAsyncOperation op = null;
+
+                        UnityDispatcher.Invoke(() => 
+                        {
+                            op = request.SendWebRequest();
+                        }).WaitOne();
+
+                        bool requestIsDone = false;
+                        bool responseCodeHandled = false;
+
+                        while (!requestIsDone)
+                        {
+                            cancellationToken.ThrowIfCancellationRequested();
+
+                            if ((DateTime.Now - lastDataAvailable).TotalMilliseconds > _timeout)
+                            {
+                                throw new ConnectionFailureException("Timeout.");
+                            }
+
+                            long requestResponseCode = 0;
+                            string requestError = null;
+
+                            UnityDispatcher.Invoke(() => 
+                            {
+                                requestIsDone = request.isDone;
+                                requestResponseCode = request.responseCode;
+                                requestError = request.error;
+                            }).WaitOne();
+
+                            if (requestError != null)
+                            {
+                                throw new ConnectionFailureException(requestError);
+                            }
+
+                            if (requestResponseCode > 0 && !responseCodeHandled)
+                            {
+                                _logger.LogDebug("Received response from server.");
+                                _logger.LogTrace("statusCode = " + requestResponseCode);
+
+                                if (Is2XXStatus((HttpStatusCode) requestResponseCode))
+                                {
+                                    _logger.LogDebug("Successful response. Reading response stream...");                             
+                                }
+                                else if (Is4XXStatus((HttpStatusCode) requestResponseCode))
+                                {
+                                    throw new DataNotAvailableException(string.Format(
+                                        "Request data for {0} is not available (status: {1})", _url, (HttpStatusCode) request.responseCode));
+                                }
+                                else
+                                {
+                                    throw new ServerErrorException(string.Format(
+                                        "Server has experienced some issues with request for {0} which resulted in {1} status code.",
+                                        _url, (HttpStatusCode) requestResponseCode));
+                                }
+
+                                responseCodeHandled = true;
+                            }
+
+                            if (dataAvailableException != null)
+                            {
+                                throw dataAvailableException;
+                            }
+
+                            System.Threading.Thread.Sleep(100);
+                        }
+
+                        if (dataAvailableException != null)
+                        {
+                            throw dataAvailableException;
+                        }
 
                         _logger.LogDebug("Stream has been read.");
                     }
-                    else if (Is4XXStatus(response.StatusCode))
-                    {
-                        throw new DataNotAvailableException(string.Format(
-                            "Request data for {0} is not available (status: {1})", _url, response.StatusCode));
-                    }
-                    else
-                    {
-                        throw new ServerErrorException(string.Format(
-                            "Server has experienced some issues with request for {0} which resulted in {1} status code.",
-                            _url, response.StatusCode));
-                    }
                 }
 
                 _logger.LogDebug("Downloading finished.");
@@ -129,17 +223,6 @@ public void Download(CancellationToken cancellationToken)
             }
         }
 
-        private void ReadResponseStream(Stream responseStream, CancellationToken cancellationToken)
-        {
-            int bufferRead;
-            while ((bufferRead = responseStream.Read(_buffer, 0, BufferSize)) > 0)
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-
-                OnDataAvailable(_buffer, bufferRead);
-            }
-        }
-
         // ReSharper disable once InconsistentNaming
         private static bool Is2XXStatus(HttpStatusCode statusCode)
         {
@@ -151,11 +234,5 @@ private static bool Is4XXStatus(HttpStatusCode statusCode)
         {
             return (int) statusCode >= 400 && (int) statusCode <= 499;
         }
-
-        private void OnDataAvailable(byte[] data, int length)
-        {
-            var handler = DataAvailable;
-            if (handler != null) handler(data, length);
-        }
     }
 }

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

@@ -176,7 +176,7 @@ private bool TryDownload(ResourceUrl url, ChunkedFileStream fileStream, Cancella
                     _logger.LogTrace("fileStream.VerifiedLength = " + fileStream.VerifiedLength);
                     _logger.LogTrace("fileStream.SavedLength = " + fileStream.SavedLength);
 
-                    var baseHttpDownloader = new BaseHttpDownloader(downloadJob.Url, _timeoutCalculator.Timeout);
+                    var baseHttpDownloader = new BaseHttpDownloader(downloadJob.Url, 30000);
                     baseHttpDownloader.SetBytesRange(downloadJob.Range);
 
                     const long downloadStatusLogInterval = 5000L;

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

@@ -120,7 +120,7 @@ private bool TryDownload(string url, FileStream fileStream, CancellationToken ca
                 const long downloadStatusLogInterval = 5000L;
                 var stopwatch = Stopwatch.StartNew();
 
-                var baseHttpDownloader = new BaseHttpDownloader(url, _requestTimeoutCalculator.Timeout);
+                var baseHttpDownloader = new BaseHttpDownloader(url, 30000);
                 baseHttpDownloader.DataAvailable += (bytes, length) =>
                 {
                     fileStream.Write(bytes, 0, length);