Merge branch 'hotfix/827-invalid-wrong-key-message'

Author: witcher112

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

@@ -128,10 +128,20 @@ public string GetProductKey()
             return _data.ProductKey;
         }
 
+        private void CreateDataDir()
+        {
+            string dirPath = Path.GetDirectoryName(_filePath);
+            if (dirPath != null)
+            {
+                Directory.CreateDirectory(dirPath);
+            }
+        }
+
         private void SaveData()
         {
             DebugLogger.Log("Saving.");
 
+            CreateDataDir();
             File.WriteAllText(_filePath, JsonConvert.SerializeObject(_data, Formatting.None));
         }
 
@@ -143,6 +153,7 @@ private void LoadData()
             {
                 if (File.Exists(_deprecatedFilePath))
                 {
+                    CreateDataDir();
                     File.Move(_deprecatedFilePath, _filePath);
                 }
             }

Assets/PatchKit Patcher/Scripts/AppData/Remote/WebRequestWraps/UnityHttpClient.cs

@@ -1,139 +1,121 @@
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Net;
+using PatchKit.Logging;
 using UnityEngine;
 using PatchKit.Network;
 using PatchKit.Unity.Patcher.Debug;
+using PatchKit.Unity.Utilities;
+using ILogger = PatchKit.Logging.ILogger;
 
 namespace PatchKit.Unity.Patcher.AppData.Remote
 {
     public class UnityHttpClient : IHttpClient
     {
-        private class RequestResult
+        private class WWWResult
         {
-            public bool IsDone;
+            public bool IsDone { get; set; }
 
-            public string Data;
-            public int StatusCode;
+            public string Text { get; set; }
 
-            public bool WasError;
-            public bool WasTimeout;
-            public string ErrorText;
+            public Dictionary<string, string> ResponseHeaders { get; set; }
         }
-        
-        private static readonly DebugLogger DebugLogger = new DebugLogger(typeof(UnityHttpClient));
+
+        private readonly ILogger _logger;
 
         private const string ResponseEncoding = "iso-8859-2";
 
-        private IEnumerator JobCoroutine(HttpGetRequest getRequest, RequestResult result)
+        public UnityHttpClient()
+        {
+            _logger = PatcherLogManager.DefaultLogger;
+        }
+
+        private IEnumerator GetWWW(HttpGetRequest getRequest, WWWResult result)
         {
             var www = new WWW(getRequest.Address.ToString());
 
             yield return www;
 
-            if (!www.isDone)
+            lock (result)
             {
-                lock (result)
+                result.IsDone = www.isDone;
+
+                if (www.isDone)
                 {
-                    result.WasTimeout = true;
-                    result.IsDone = true;
+                    result.ResponseHeaders = www.responseHeaders;
+                    result.Text = www.text;
                 }
-                yield break;
             }
+        }
 
-            if (!string.IsNullOrEmpty(www.error))
+        public IHttpResponse Get(HttpGetRequest getRequest)
+        {
+            try
             {
-                lock (result)
+                _logger.LogDebug("Sending GET request to " + getRequest.Address);
+
+                if (getRequest.Range != null)
                 {
-                    result.ErrorText = www.error;
-                    result.WasError = true;
-                    result.IsDone = true;
+                    throw new NotImplementedException();
                 }
-                yield break;
-            }
 
-            var wwwText = www.text;
+                _logger.LogTrace("timeout  = " + getRequest.Timeout);
+            
+                var result = new WWWResult();
 
-            if (string.IsNullOrEmpty(wwwText))
-            {
-                lock (result)
-                {
-                    result.ErrorText = "Empty response data";
-                    result.WasError = true;
-                    result.IsDone = true;
-                }
-                yield break;
-            }
+                var waitHandle = UnityDispatcher.InvokeCoroutine(GetWWW(getRequest, result));
+            
+                waitHandle.WaitOne(TimeSpan.FromMilliseconds(getRequest.Timeout));
 
-            lock (result)
-            {
-                try
+                lock (result)
                 {
-                    result.Data = wwwText;
-
-                    if (!www.responseHeaders.ContainsKey("STATUS"))
-                    {
-                        // Based on tests, if response doesn't contain status it has probably timed out.
-                        DebugLogger.Log("Response is missing STATUS header. Marking it as timed out.");
-                        result.WasTimeout = true;
-                    }
-                    else
+                    if (!result.IsDone)
                     {
-                        var status = www.responseHeaders["STATUS"];
-                        DebugLogger.Log(string.Format("Response status: {0}", status));
-                        var s = status.Split(' ');
-
-                        if (s.Length >= 3 && int.TryParse(s[1], out result.StatusCode))
-                        {
-                            DebugLogger.Log(string.Format("Successfully parsed status code: {0}", result.StatusCode));
-                        }
-                        else
-                        {
-                            // Based on tests, if response contains invalid status it has probably timed out.
-                            DebugLogger.Log(string.Format("Response has invalid status - {0}. Marking it as timed out.",
-                                status));
-                            result.WasTimeout = true;
-                        }
+                        throw new WebException("Timeout.", WebExceptionStatus.Timeout);
                     }
-                }
-                catch (Exception e)
-                {
-                    result.WasError = true;
-                    result.ErrorText = e.ToString();
-                }
-                finally
-                {
-                    result.IsDone = true;
+
+                    var statusCode = ReadStatusCode(result);
+
+                    _logger.LogDebug("Successfuly received response.");
+                    return new UnityHttpResponse(result.Text, statusCode, ResponseEncoding);
                 }
             }
-
-            yield return null;
+            catch (Exception e)
+            {
+                _logger.LogError("Failed to get response.", e);
+                throw;
+            }
         }
 
-        public IHttpResponse Get(HttpGetRequest getRequest)
+        private HttpStatusCode ReadStatusCode(WWWResult result)
         {
-            if (getRequest.Range != null)
+            _logger.LogDebug("Reading status code...");
+
+            if (!result.ResponseHeaders.ContainsKey("STATUS"))
             {
-                throw new NotImplementedException();
+                // Based on tests, if response doesn't contain status it has probably timed out.
+                _logger.LogWarning("Response is missing STATUS header. Marking it as timed out.");
+                throw new WebException("Timeout.", WebExceptionStatus.Timeout);
             }
-            
-            var result = new RequestResult();
 
-            var waitHandle = Utilities.UnityDispatcher.InvokeCoroutine(JobCoroutine(getRequest, result));
-            
-            waitHandle.WaitOne(TimeSpan.FromMilliseconds(getRequest.Timeout));
+            var status = result.ResponseHeaders["STATUS"];
+            _logger.LogTrace("status = " + status);
+
+            var s = status.Split(' ');
+
+            int statusCode;
 
-            if (result.WasTimeout || !result.IsDone)
+            if (s.Length < 3 || !int.TryParse(s[1], out statusCode))
             {
+                _logger.LogWarning("Response has invalid status. Marking it as timed out.");
                 throw new WebException("Timeout.", WebExceptionStatus.Timeout);
             }
 
-            if (result.WasError)
-            {
-                throw new WebException(result.ErrorText);
-            }
+            _logger.LogTrace("statusCode = " + statusCode);
+            _logger.LogTrace("statusCode (as enum) = " + (HttpStatusCode) statusCode);
 
-            return new UnityHttpResponse(result.Data, result.StatusCode, ResponseEncoding);
+            return (HttpStatusCode) statusCode;
         }
     }
 }

Assets/PatchKit Patcher/Scripts/AppData/Remote/WebRequestWraps/UnityHttpResponse.cs

@@ -7,10 +7,10 @@ namespace PatchKit.Unity.Patcher.AppData.Remote
     public class UnityHttpResponse : IHttpResponse
     {
         private readonly string _data;
-        private readonly int _statusCode;
+        private readonly System.Net.HttpStatusCode _statusCode;
         private MemoryStream _contentStream;
 
-        public UnityHttpResponse(string data, int statusCode, string charset)
+        public UnityHttpResponse(string data, System.Net.HttpStatusCode statusCode, string charset)
         {
             if (data == null) throw new ArgumentNullException("data");
 
@@ -42,7 +42,7 @@ public Stream ContentStream
 
         public System.Net.HttpStatusCode StatusCode
         {
-            get { return (System.Net.HttpStatusCode) _statusCode; }
+            get { return _statusCode; }
         }
 
         public void Dispose()