private static Settings CreateSettingsInstance()
{
bool pingObject = false;
if (UnityEditor.EditorApplication.isPlaying)
{
UnityEditor.EditorApplication.isPaused = true;
UnityEditor.EditorUtility.DisplayDialog("PatchKit Settings has been created.",
"PatchKit Settings asset has been created.", "OK");
pingObject = true;
}
var settings = CreateInstance <Settings>();
settings.MainApiConnectionSettings = MainApiConnection.GetDefaultSettings();
settings.KeysApiConnectionSettings = KeysApiConnection.GetDefaultSettings();
UnityEditor.AssetDatabase.CreateAsset(settings,
string.Format("Assets/PatchKit Patcher/Resources/{0}.asset", AssetFileName));
UnityEditor.EditorUtility.SetDirty(settings);
UnityEditor.AssetDatabase.Refresh();
UnityEditor.AssetDatabase.SaveAssets();
if (pingObject)
{
UnityEditor.EditorGUIUtility.PingObject(settings);
}
return(settings);
}
public RemoteData(string appSecret)
{
Checks.ArgumentNotNullOrEmpty(appSecret, "appSecret");
DebugLogger.LogConstructor();
DebugLogger.LogVariable(appSecret, "appSecret");
_appSecret = appSecret;
var mainSettings = Settings.GetMainApiConnectionSettings();
string overrideMainUrl;
if (EnvironmentInfo.TryReadEnvironmentVariable(EnvironmentVariables.MainUrlEnvironmentVariable, out overrideMainUrl))
{
var overrideMainUri = new Uri(overrideMainUrl);
mainSettings.MainServer.Host = overrideMainUri.Host;
mainSettings.MainServer.Port = overrideMainUri.Port;
mainSettings.MainServer.UseHttps = overrideMainUri.Scheme == Uri.UriSchemeHttps;
}
_mainApiConnection = new MainApiConnection(mainSettings)
{
HttpWebRequestFactory = new UnityWebRequestFactory(),
Logger = PatcherLogManager.DefaultLogger
};
}
public static ApiConnectionSettings GetMainApiConnectionSettings()
{
var instance = FindInstance();
var settings = instance == null
? MainApiConnection.GetDefaultSettings()
: instance.MainApiConnectionSettings;
var overrideMain = GetApiConnectionServerFromEnvVar(EnvironmentVariables.ApiUrlEnvironmentVariable);
if (overrideMain.HasValue)
{
settings.MainServer = overrideMain.Value;
}
var overrideMainCache =
GetApiConnectionServerFromEnvVar(EnvironmentVariables.ApiCacheUrlEnvironmentVariable);
if (overrideMainCache.HasValue)
{
settings.CacheServers = new[] { overrideMainCache.Value };
}
return(settings);
}
public RemoteData(string appSecret, IRequestTimeoutCalculator requestTimeoutCalculator)
{
Checks.ArgumentNotNullOrEmpty(appSecret, "appSecret");
DebugLogger.LogConstructor();
DebugLogger.LogVariable(appSecret, "appSecret");
_appSecret = appSecret;
var mainSettings = Settings.GetMainApiConnectionSettings();
string overrideMainUrl;
if (EnvironmentInfo.TryReadEnvironmentVariable(EnvironmentVariables.ApiUrlEnvironmentVariable, out overrideMainUrl))
{
var overrideMainUri = new Uri(overrideMainUrl);
mainSettings.MainServer.Host = overrideMainUri.Host;
mainSettings.MainServer.Port = overrideMainUri.Port;
mainSettings.MainServer.UseHttps = overrideMainUri.Scheme == Uri.UriSchemeHttps;
}
_mainApiConnection = new MainApiConnection(mainSettings)
{
HttpClient = new UnityHttpClient(),
RequestTimeoutCalculator = requestTimeoutCalculator,
RequestRetryStrategy = new SimpleInfiniteRequestRetryStrategy(),
Logger = PatcherLogManager.DefaultLogger
};
}
protected override IEnumerator LoadCoroutine()
{
yield return(Threading.StartThreadCoroutine(() => MainApiConnection.GetAppLatestAppVersion(AppSecret),
response =>
{
Text.text = response.Label;
}));
}
protected override IEnumerator LoadCoroutine()
{
yield return(Threading.StartThreadCoroutine(() => MainApiConnection.GetAppLatestAppVersion(AppSecret, CancellationToken.Empty),
response =>
{
Text.text = response.Changelog;
}));
}
public RemoteData(string appSecret, MainApiConnection mainApiConnection)
{
Checks.ArgumentNotNullOrEmpty(appSecret, "appSecret");
Checks.ArgumentNotNull(mainApiConnection, "mainApiConnection");
DebugLogger.LogConstructor();
DebugLogger.LogVariable(appSecret, "appSecret");
_appSecret = appSecret;
_mainApiConnection = mainApiConnection;
}
public void TestSingle()
{
var apiConnection = new MainApiConnection(_apiConnectionSettings)
{
HttpClient = Substitute.For <IHttpClient>()
};
AddGetResponseToClient(apiConnection.HttpClient, "http://main_server/path?query",
CreateSimpleWebResponse("test"));
var apiResponse = apiConnection.Get("/path", "query");
Assert.AreEqual("test", apiResponse.Body);
}
public void Post_InCaseOf404_DoesntUseCacheServers()
{
var apiConnection = new MainApiConnection(_apiConnectionSettings)
{
HttpClient = Substitute.For <IHttpClient>()
};
AddPostResponseToClient(apiConnection.HttpClient, "http://main_server/path?query",
CreateErrorResponse(HttpStatusCode.NotFound));
Assert.That(() => apiConnection.Post("/path", "query", "body"), Throws.Exception.TypeOf <ApiResponseException>());
apiConnection.HttpClient.DidNotReceive().Post(MatchPostRequest("http://cache_server_1/path?query"));
apiConnection.HttpClient.DidNotReceive().Post(MatchPostRequest("http://cache_server_2/path?query"));
}
public void Post_InCaseOfConnectionIssue_DoesntUseCacheServers()
{
var apiConnection = new MainApiConnection(_apiConnectionSettings)
{
HttpClient = Substitute.For <IHttpClient>()
};
AddPostThrowToClient(apiConnection.HttpClient, "http://main_server/path?query",
new WebException("main-server"));
Assert.That(() => apiConnection.Post("/path", "query", "body"), Throws.Exception.TypeOf <ApiConnectionException>());
apiConnection.HttpClient.DidNotReceive().Post(MatchPostRequest("http://cache_server_1/path?query"));
apiConnection.HttpClient.DidNotReceive().Post(MatchPostRequest("http://cache_server_2/path?query"));
}
public void Post()
{
var apiConnection = new MainApiConnection(_apiConnectionSettings)
{
HttpClient = Substitute.For <IHttpClient>()
};
AddPostResponseToClient(apiConnection.HttpClient, "http://main_server/path?query",
CreateSimpleWebResponse("abc"));
var response = apiConnection.Post("path", "query", "123");
Assert.That(response.Body, Is.EqualTo("abc"));
apiConnection.HttpClient.Received(1).Post(MatchPostRequest("http://main_server/path?query", "123"));
}
// ReSharper disable once InconsistentNaming
public void Test4XXException()
{
// any 4XX error from the main server should throw an ApiResponseException
var apiConnection = new MainApiConnection(_apiConnectionSettings)
{
HttpClient = Substitute.For <IHttpClient>()
};
AddGetResponseToClient(apiConnection.HttpClient, "http://main_server/path?query",
CreateErrorResponse(HttpStatusCode.NotFound));
Assert.Throws(
Is.TypeOf <ApiResponseException>(),
() => apiConnection.Get("/path", "query")
);
}
protected override IEnumerator LoadCoroutine()
{
while (!Patcher.Instance.Data.HasValue || Patcher.Instance.Data.Value.AppSecret == null)
{
yield return(null);
}
yield return
(Threading.StartThreadCoroutine(() => MainApiConnection.GetAppVersionList(Patcher.Instance.Data.Value.AppSecret),
response =>
{
foreach (var version in response.OrderByDescending(version => version.Id))
{
CreateVersionChangelog(version);
}
}));
}
protected override IEnumerator LoadCoroutine()
{
yield return(Threading.StartThreadCoroutine(() => MainApiConnection.GetAppVersionList(AppSecret), response =>
{
Text.text = string.Join("\n",
response.OrderByDescending(version => version.Id).Select(version =>
{
string changelog = Format;
changelog = changelog.Replace("{label}", version.Label);
changelog = changelog.Replace("{changelog}", version.Changelog);
string publishDate = UnixTimeConvert.FromUnixTimeStamp(version.PublishDate).ToString("g");
changelog = changelog.Replace("{publishdate}", publishDate);
return changelog;
}).ToArray());
}));
}
public void TestGetDiffUrls()
{
var apiConnection = new MainApiConnection(_apiConnectionSettings)
{
HttpClient = Substitute.For <IHttpClient>()
};
AddGetResponseToClient(apiConnection.HttpClient, "http://main_server/1/apps/secret/versions/13/diff_urls",
CreateSimpleWebResponse(
"[{\"url\": \"http://first\", \"meta_url\": \"http://efg\", \"country\": \"PL\"}, " +
"{\"url\": \"http://second\", \"meta_url\": \"http://efg\"}]"));
var contentUrls = apiConnection.GetAppVersionDiffUrls("secret", 13);
Assert.AreEqual(2, contentUrls.Length);
Assert.AreEqual("http://first", contentUrls[0].Url);
Assert.AreEqual("PL", contentUrls[0].Country);
Assert.AreEqual(null, contentUrls[1].Country);
}
// ReSharper disable once InconsistentNaming
public void Test5XXException()
{
// any 5XX error from the main server should throw an ApiConnectionException
var apiConnection = new MainApiConnection(_apiConnectionSettings)
{
HttpClient = Substitute.For <IHttpClient>()
};
AddGetResponseToClient(apiConnection.HttpClient, "http://main_server/path?query",
CreateErrorResponse(HttpStatusCode.InternalServerError));
var exception = (ApiConnectionException)Assert.Throws(
Is.TypeOf <ApiConnectionException>(),
() => apiConnection.Get("/path", "query")
);
Assert.IsTrue(exception.MainServerExceptions.Any());
Assert.IsTrue(exception.CacheServersExceptions.Any());
}
protected override IEnumerator LoadCoroutine()
{
while (!Patcher.Instance.Data.HasValue || Patcher.Instance.Data.Value.AppSecret == null)
{
yield return(null);
}
var appSecret = Patcher.Instance.Data.Value.AppSecret;
LoadChangelogFromCache(appSecret);
yield return
(Threading.StartThreadCoroutine(() =>
MainApiConnection.GetAppVersionList(
Patcher.Instance.Data.Value.AppSecret,
null,
CancellationToken.Empty),
versions => CreateAndCacheChangelog(appSecret, versions)));
}
public RemoteMetaData([NotNull] string appSecret, [NotNull] IRequestTimeoutCalculator requestTimeoutCalculator)
{
if (string.IsNullOrEmpty(appSecret))
{
throw new ArgumentException("Value cannot be null or empty.", "appSecret");
}
if (requestTimeoutCalculator == null)
{
throw new ArgumentNullException("requestTimeoutCalculator");
}
DebugLogger.LogConstructor();
DebugLogger.LogVariable(appSecret, "appSecret");
_appSecret = appSecret;
var mainSettings = Settings.GetMainApiConnectionSettings();
_mainApiConnection = new MainApiConnection(mainSettings)
{
HttpClient = new UnityHttpClient(),
RequestTimeoutCalculator = requestTimeoutCalculator,
RequestRetryStrategy = new SimpleInfiniteRequestRetryStrategy(),
Logger = PatcherLogManager.DefaultLogger
};
_mainApiConnectionWithoutRetry = new MainApiConnection(mainSettings)
{
HttpClient = new UnityHttpClient(),
RequestTimeoutCalculator = requestTimeoutCalculator,
Logger = PatcherLogManager.DefaultLogger
};
var keysSettings = Settings.GetKeysApiConnectionSettings();
_keysApiConnection = new KeysApiConnection(keysSettings)
{
HttpClient = new UnityHttpClient(),
RequestTimeoutCalculator = requestTimeoutCalculator,
Logger = PatcherLogManager.DefaultLogger
};
}
public void TestApiCache500()
{
// test how connection will behave on 500 error
var apiConnection = new MainApiConnection(_apiConnectionSettings)
{
HttpClient = Substitute.For <IHttpClient>()
};
// main
AddGetResponseToClient(apiConnection.HttpClient, "http://main_server/path?query",
CreateErrorResponse(HttpStatusCode.InternalServerError));
// cache
AddGetResponseToClient(apiConnection.HttpClient, "http://cache_server_1/path?query",
CreateSimpleWebResponse("test"));
var apiResponse = apiConnection.Get("/path", "query");
Assert.AreEqual("test", apiResponse.Body);
}
// ReSharper disable once InconsistentNaming
public void TestCache4XXException()
{
var apiConnection = new MainApiConnection(_apiConnectionSettings)
{
HttpClient = Substitute.For <IHttpClient>()
};
AddGetThrowToClient(apiConnection.HttpClient, "http://main_server/path?query",
new WebException("main-server"));
AddGetThrowToClient(apiConnection.HttpClient, "http://cache_server_1/path?query",
new WebException("cache-server-1"));
AddGetResponseToClient(apiConnection.HttpClient, "http://cache_server_2/path?query",
CreateErrorResponse(HttpStatusCode.NotFound));
var exception = (ApiConnectionException)Assert.Throws(
Is.TypeOf <ApiConnectionException>(),
() => apiConnection.Get("/path", "query")
);
Assert.IsTrue(exception.MainServerExceptions.All(e => e.Message == "main-server"));
Assert.IsTrue(exception.CacheServersExceptions.Any(e => e.Message == "cache-server-1"));
}
public void TestErrorOnCache()
{
// Any code different than 200 on API cache should skip it
var apiConnection = new MainApiConnection(_apiConnectionSettings)
{
HttpClient = Substitute.For <IHttpClient>()
};
// main
AddGetResponseToClient(apiConnection.HttpClient, "http://main_server/path?query",
CreateErrorResponse(HttpStatusCode.BadGateway));
// cache1
AddGetResponseToClient(apiConnection.HttpClient, "http://cache_server_1/path?query",
CreateErrorResponse(HttpStatusCode.NotFound));
// cache2
AddGetResponseToClient(apiConnection.HttpClient, "http://cache_server_2/path?query",
CreateSimpleWebResponse("test"));
var apiResponse = apiConnection.Get("/path", "query");
Assert.AreEqual("test", apiResponse.Body);
}
protected virtual void Awake()
{
_mainApiConnection = new MainApiConnection(Settings.GetMainApiConnectionSettings());
_mainApiConnection.HttpClient = new UnityHttpClient();
}
public RemoteMetaData([NotNull] string appSecret, [NotNull] IRequestTimeoutCalculator requestTimeoutCalculator)
{
if (string.IsNullOrEmpty(appSecret))
{
throw new ArgumentException("Value cannot be null or empty.", "appSecret");
}
if (requestTimeoutCalculator == null)
{
throw new ArgumentNullException("requestTimeoutCalculator");
}
DebugLogger.LogConstructor();
DebugLogger.LogVariable(appSecret, "appSecret");
_appSecret = appSecret;
var mainSettings = Settings.GetMainApiConnectionSettings();
string overrideMainUrl;
if (EnvironmentInfo.TryReadEnvironmentVariable(EnvironmentVariables.MainUrlEnvironmentVariable, out overrideMainUrl))
{
var overrideMainUri = new Uri(overrideMainUrl);
mainSettings.MainServer.Host = overrideMainUri.Host;
mainSettings.MainServer.Port = overrideMainUri.Port;
mainSettings.MainServer.UseHttps = overrideMainUri.Scheme == Uri.UriSchemeHttps;
}
_mainApiConnection = new MainApiConnection(mainSettings)
{
HttpClient = new UnityHttpClient(),
RequestTimeoutCalculator = requestTimeoutCalculator,
RequestRetryStrategy = new SimpleInfiniteRequestRetryStrategy(),
Logger = PatcherLogManager.DefaultLogger
};
_mainApiConnectionWithoutRetry = new MainApiConnection(mainSettings)
{
HttpClient = new UnityHttpClient(),
RequestTimeoutCalculator = requestTimeoutCalculator,
Logger = PatcherLogManager.DefaultLogger
};
var keysSettings = Settings.GetKeysApiConnectionSettings();
string overrideKeysUrl;
if (EnvironmentInfo.TryReadEnvironmentVariable(EnvironmentVariables.KeysUrlEnvironmentVariable, out overrideKeysUrl))
{
var overrideKeysUri = new Uri(overrideKeysUrl);
keysSettings.MainServer.Host = overrideKeysUri.Host;
keysSettings.MainServer.Port = overrideKeysUri.Port;
keysSettings.MainServer.UseHttps = overrideKeysUri.Scheme == Uri.UriSchemeHttps;
}
_keysApiConnection = new KeysApiConnection(keysSettings)
{
HttpClient = new UnityHttpClient(),
RequestTimeoutCalculator = requestTimeoutCalculator,
Logger = PatcherLogManager.DefaultLogger
};
}
protected virtual void Awake()
{
_mainApiConnection = new MainApiConnection(Settings.GetMainApiConnectionSettings());
}
public static ApiConnectionSettings GetMainApiConnectionSettings()
{
var instance = FindInstance();
return(instance == null?MainApiConnection.GetDefaultSettings() : instance.MainApiConnectionSettings);
}
