/// <summary>
/// DoCdnAction
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="req"></param>
/// <param name="json"></param>
private static void DoCdnAction<T>(out CdnClient client, out T req, string json)
{
DoTencentCloudAction("cdn", out Credential cred, out ClientProfile clientProfile);
client = new CdnClient(cred, "", clientProfile);
req = AbstractModel.FromJsonString<T>(json);
}
public async Task <CdnClient> GetClientAsync(AppId appId, DepotId depotId, CancellationToken cancellationToken = default)
{
await _getClientSemaphore.WaitAsync(cancellationToken);
if (_cdnClientWrappersAvailable.Count == 0)
{
await FillServerPoolAsync();
}
await _poolFilledEvent.WaitAsync(cancellationToken);
CdnClient recommendedClient = null;
lock (this)
{
recommendedClient = _cdnClientWrappersAvailable
.OrderByDescending(x => x.ServerWrapper.Score)
.ThenBy(x => x.ServerWrapper.Server.WeightedLoad)
.ThenBy(x => x.ServerWrapper.Server.Load)
.Take(10)
.OrderBy(x => _random.Next())
.First();
_cdnClientWrappersAvailable.Remove(recommendedClient);
}
if (recommendedClient.RequiresAuthentication(appId, depotId))
{
await AuthenticateClientInfoAsync(recommendedClient, appId, depotId);
}
_getClientSemaphore.Release();
return(recommendedClient);
}
public async Task CreateAndAuthenticate()
{
_client = new CdnClient(Constants.BaseUrl);
var resp = await _client.Login("admin", "password");
Assert.IsTrue(resp.HasValue);
Assert.IsNotEmpty(resp.Value.Token);
}
public async Task RegisterTest()
{
using var client = new CdnClient(Constants.BaseUrl);
var registerResponse = await client.Register("testUser", "123456");
Assert.IsTrue(registerResponse.HasValue);
Assert.AreEqual("testuser", registerResponse.Value.Username);
}
public async Task AuthTestWithoutLogin()
{
using var client = new CdnClient(Constants.BaseUrl);
(bool success, string message) = await client.TestAuthentication();
Assert.IsFalse(success);
Assert.IsNull(message);
}
public async Task LoginTest()
{
using var client = new CdnClient(Constants.BaseUrl);
var loginDto = await client.Login("admin", "password");
Assert.IsTrue(loginDto.HasValue);
Assert.AreEqual("admin", loginDto.Value.User.Username);
Assert.IsNotNull(loginDto.Value.Token);
Assert.IsNotEmpty(loginDto.Value.Token);
}
public async Task LoginAuthTest()
{
using var client = new CdnClient(Constants.BaseUrl);
await client.Login("admin", "password");
(bool success, string message) = await client.TestAuthentication();
Assert.IsTrue(success);
Assert.IsNotEmpty(message);
}
public async Task TestRemoveApiKey()
{
using var client = new CdnClient(Constants.BaseUrl);
await client.Login("admin", "password");
var tokenMaybe = await client.GetApiKey();
Assert.IsTrue(tokenMaybe.HasValue);
Assert.IsNotEmpty(tokenMaybe.Value);
await client.DeleteApiKey();
Assert.AreEqual(AuthenticationType.Jwt, client.CurrentAuthenticationType);
}
public async Task GetApiKeyAndTestAuthentication()
{
using var client = new CdnClient(Constants.BaseUrl);
await client.Login("admin", "password");
var tokenMaybe = await client.GetApiKey();
Assert.IsTrue(tokenMaybe.HasValue);
Assert.IsNotEmpty(tokenMaybe.Value);
(bool success, string message) = await client.TestAuthentication();
Assert.IsTrue(success);
Assert.IsNotEmpty(message);
}
public async Task CreateAndAuthenticate()
{
_client = new CdnClient(Constants.BaseUrl);
var resp = await _client.Login("admin", "password");
Assert.IsTrue(resp.HasValue);
Assert.IsNotEmpty(resp.Value.Token);
// Create an album that is going to be deleted
_albumToBeDeleted = (await _client.CreateAlbum("testAlbum").ConfigureAwait(false)).Value;
Assert.NotNull(_albumToBeDeleted);
_albumUsedForTestingPrivate = (await _client.CreateAlbum("testAlbum2", false).ConfigureAwait(false)).Value;
Assert.NotNull(_albumUsedForTestingPrivate);
_albumUsedForTesting = (await _client.CreateAlbum("testAlbum123").ConfigureAwait(false)).Value;
Assert.NotNull(_albumUsedForTesting);
}
public async Task CreateAndAuthenticate()
{
_client = new CdnClient(Constants.BaseUrl);
var resp = await _client.Login("admin", "password");
Assert.IsTrue(resp.HasValue);
Assert.IsNotEmpty(resp.Value.Token);
// Add dummy user to remove
var userToRemove = await _client.Register("removeMePlease", "password");
var userToRename = await _client.Register("changeMyName", "password");
Assert.IsTrue(userToRemove.HasValue);
Assert.IsTrue(userToRename.HasValue);
_userToRemove = userToRemove.Value;
_userToRename = userToRename.Value;
}
private async Task AuthenticateClientInfoAsync(CdnClient client, AppId appId, DepotId depotId)
{
if (client.ServerWrapper.Server.Type == "CDN" || client.ServerWrapper.Server.Type == "SteamCache")
{
var authToken = client.GetAuthTokenOrDefault(appId, depotId);
if (authToken == null)
{
var result = await _steamApps.GetCDNAuthToken(appId, depotId, client.ServerWrapper.Server.Host);
authToken = new CdnClientAuthToken(result.Token, result.Expiration, appId, depotId);
client.AuthTokens.Add(authToken);
}
client.InternalCdnClient.AuthenticateDepot(depotId, await GetDepotKeyAsync(depotId, appId), authToken.Token);
}
}
/// <summary>
/// DoCdnAction
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="req"></param>
/// <param name="json"></param>
private static void DoCdnAction <T>(out CdnClient client, out T req, string json)
{
var cred = new Credential
{
SecretId = AppSettings.TencentCloud.SecretId,
SecretKey = AppSettings.TencentCloud.SecretKey
};
var httpProfile = new HttpProfile {
Endpoint = "cdn.tencentcloudapi.com"
};
var clientProfile = new ClientProfile {
HttpProfile = httpProfile
};
client = new CdnClient(cred, "", clientProfile);
req = AbstractModel.FromJsonString <T>(json);
}
private void DoCdnAction <T>(out CdnClient client, out T req, string json)
{
var cred = new Credential
{
SecretId = _tencentCloudOptions.SecretId,
SecretKey = _tencentCloudOptions.SecretKey
};
var httpProfile = new HttpProfile {
Endpoint = $"cdn.tencentcloudapi.com"
};
var clientProfile = new ClientProfile {
HttpProfile = httpProfile
};
client = new CdnClient(cred, "", clientProfile);
req = json.DeserializeToObject <T>();
}
public async Task CreateAndAuthenticate()
{
_client = new CdnClient(Constants.BaseUrl);
var resp = await _client.Login("admin", "password");
Assert.IsTrue(resp.HasValue);
Assert.IsNotEmpty(resp.Value.Token);
// Upload files to be used in further tests
_uploadedFiles = (await this.UploadMultipleFilesNoParameters().ConfigureAwait(false)).ToList();
// Upload one private file
var file = await _client.UploadFile(FileUploadTests.GetExampleImage(), "privateTestfile", false);
Assert.IsTrue(file.HasValue);
Assert.NotNull(file.Value);
_uploadedFiles.Add(file.Value);
Assert.IsNotEmpty(_uploadedFiles);
}
public void ReturnClient(CdnClient cdnClientWrapper, bool isFunctional = true)
{
if (cdnClientWrapper == null)
{
return;
}
lock (this)
{
if (isFunctional)
{
cdnClientWrapper.ServerWrapper.Score += 0.1;
_cdnClientWrappersAvailable.Add(cdnClientWrapper);
}
else
{
cdnClientWrapper.ServerWrapper.Score -= 1;
}
}
SaveServerQualitiesMemory();
}
public CyberSecManager(AppSettings appSettings, IAnalyticsManager analyticsManager, CdnClient cndClient)
{
this._appSettings = appSettings;
this._analyticsManager = analyticsManager;
this._cndClient = cndClient;
}
public async Task SetupTestAccount()
{
using var client = new CdnClient(Constants.BaseUrl);
await client.Register("daniele", "123456");
}
public async Task FillServerPoolAsync()
{
// Await until we've logged in and have our suggest cell ID
await _steamContentClient.SteamClient.AwaitReadyAsync(_steamContentClient.SteamClient.CancellationToken);
// Add any not-yet-tracked servers
var servers = await GetServersAsync();
foreach (var server in servers)
{
if (_servers.Any(x => x.Server.Host == server.Host))
{
continue;
}
var serverWrapper = new CdnServerWrapper(server);
var qualityFromMemory = _steamContentServerQualities.FirstOrDefault(x => x.Host == serverWrapper.Server.Host);
if (qualityFromMemory != null)
{
serverWrapper.Score = qualityFromMemory.Score;
}
_servers.Add(serverWrapper);
}
// Fresh database over server quality
if (_servers.Sum(x => x.Score) == 0)
{
foreach (var serverWrapper in _servers)
{
for (int i = 0; i < serverWrapper.Server.NumEntries; i++)
{
var cdnClient = new CDNClient(_steamContentClient.SteamClient.InternalClient);
//await cdnClient.ConnectAsync(serverWrapper.Server);
var wrapper = new CdnClient(cdnClient, serverWrapper);
_cdnClientWrappersAvailable.Add(wrapper);
}
}
}
else
{
var orderedServers = new Queue <CdnServerWrapper>(_servers.OrderByDescending(x => x.Score).OrderBy(x => x.Server.WeightedLoad).OrderBy(x => x.Server.Load));
int refillsRemaining = CLIENTS_REFILL_LIMIT;
while (orderedServers.Count > 0)
{
var serverWrapper = orderedServers.Dequeue();
for (int i = 0; i < serverWrapper.Server.NumEntries; i++)
{
var cdnClient = new CDNClient(_steamContentClient.SteamClient.InternalClient);
var wrapper = new CdnClient(cdnClient, serverWrapper);
_cdnClientWrappersAvailable.Add(wrapper);
if (--refillsRemaining <= 0)
{
break;
}
}
}
}
_poolFilledEvent.Set();
}
