public void prepareSkinAsync(string carId, string skinChecksum, string skinUrl, IJavascriptCallback callback)
{
ActionExtension.InvokeInMainThreadAsync(async() => {
var car = await CarsManager.Instance.GetByIdAsync(carId);
if (car == null)
{
callback?.ExecuteAsync($"Car with ID={carId} is missing");
return;
}
var cacheDirectory = FilesStorage.Instance.GetTemporaryDirectory("RaceU", "Skins", carId);
var destinationFilename = Path.Combine(cacheDirectory, skinChecksum);
if (File.Exists(destinationFilename))
{
callback?.ExecuteAsync(null);
return;
}
try {
var data = await HttpClientHolder.Get().GetByteArrayAsync(skinUrl);
await FileUtils.WriteAllBytesAsync(destinationFilename, data);
} catch (Exception e) {
callback?.ExecuteAsync($"Failed to download skin: {e.Message}");
return;
}
callback?.ExecuteAsync(null);
});
}
private static async Task UploadBinaryDataAsync(string endpoint, Func <Task <byte[]> > dataCallback, IJavascriptCallback callback)
{
string ret;
try {
var response = await HttpClientHolder.Get().PostAsync(endpoint, new ByteArrayContent(await dataCallback()));
response.EnsureSuccessStatusCode();
ret = await response.Content.ReadAsStringAsync();
} catch (Exception e) {
callback?.ExecuteAsync($"Failed to upload: {e.Message}", null);
return;
}
callback?.ExecuteAsync(null, ret);
}
public void uploadCarSkinAsync(string carId, string skinId, string endpoint, IJavascriptCallback callback)
{
ActionExtension.InvokeInMainThreadAsync(async() => {
var skin = await GetSkinAsync(carId, skinId, callback);
if (skin == null)
{
return;
}
byte[] data = null;
try {
await Task.Run(() => {
using (var stream = new MemoryStream()) {
using (var zip = new ZipArchive(stream, ZipArchiveMode.Create, true)) {
foreach (var file in GetSkinFiles(skin))
{
zip.CreateEntryFromFile(file.FullName, file.Name);
}
}
data = stream.ToArray();
}
});
} catch (Exception e) {
callback?.ExecuteAsync($"Failed to compress files: {e.Message}", null);
return;
}
string ret;
try {
var response = await HttpClientHolder.Get().PostAsync(endpoint, new ByteArrayContent(data));
response.EnsureSuccessStatusCode();
ret = await response.Content.ReadAsStringAsync();
} catch (Exception e) {
callback?.ExecuteAsync($"Failed to upload: {e.Message}", null);
return;
}
callback?.ExecuteAsync(null, ret);
});
}
public B2WorkshopUploader(JObject uploadParams)
{
HttpClientFactory.SetHttpClient(HttpClientHolder.Get());
var config = uploadParams.ToString();
if (_b2ClientConfig == config)
{
_b2Client = _b2ClientLast;
}
else
{
_b2Client = new B2Client(new B2Options {
KeyId = uploadParams["keyID"].ToString(),
ApplicationKey = uploadParams["keyValue"].ToString(),
BucketId = uploadParams["bucketID"].ToString(),
PersistBucket = true
});
_b2ClientLast = _b2Client;
_b2ClientConfig = config;
}
_b2ClientPrefix = uploadParams["prefix"].ToString();
}
public async Task <WorkshopUploadResult> UploadAsync(byte[] data, string group, string name,
IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default)
{
for (var i = 0; i < 3; ++i)
{
progress?.Report(AsyncProgressEntry.FromStringIndetermitate(i == 0
? "Starting upload…"
: $"Trying again, {(i + 1).ToOrdinal("attempt").ToSentenceMember()} attempt"));
try {
return(await TryToUploadAsync());
} catch (HttpRequestException e) {
Logging.Warning(e);
cancellation.ThrowIfCancellationRequested();
progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Upload is failed, waiting a bit before the next attempt…"));
await Task.Delay(TimeSpan.FromSeconds(i + 1d));
cancellation.ThrowIfCancellationRequested();
} catch (WebException e) {
Logging.Warning(e);
cancellation.ThrowIfCancellationRequested();
progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Upload is failed, waiting a bit before the next attempt…"));
await Task.Delay(TimeSpan.FromSeconds(i + 1d));
cancellation.ThrowIfCancellationRequested();
}
}
cancellation.ThrowIfCancellationRequested();
progress?.Report(AsyncProgressEntry.FromStringIndetermitate($"Trying again, last attempt"));
return(await TryToUploadAsync());
async Task <WorkshopUploadResult> TryToUploadAsync()
{
var request = new HttpRequestMessage(HttpMethod.Post, _endpoint);
request.Headers.TryAddWithoutValidation("X-Data-File-Group", group);
request.Headers.TryAddWithoutValidation("X-Data-File-Name", name);
request.Headers.TryAddWithoutValidation("X-Data-Checksum", _checksum);
var stopwatch = new AsyncProgressBytesStopwatch();
request.Content = progress == null
? (HttpContent) new ByteArrayContent(data)
: new ProgressableByteArrayContent(data, 8192,
new Progress <long>(x => progress.Report(AsyncProgressEntry.CreateUploading(x, data.Length, stopwatch))));
using (var response = await HttpClientHolder.Get().SendAsync(request, cancellation).ConfigureAwait(false)) {
if (response.StatusCode != HttpStatusCode.OK)
{
throw new WebException($"Failed to upload: {response.StatusCode}, response: {await LoadContent()}");
}
var result = JObject.Parse(await LoadContent());
return(new WorkshopUploadResult {
Size = data.Length,
Tag = result["key"].ToString()
});
ConfiguredTaskAwaitable <string> LoadContent()
{
return(response.Content.ReadAsStringAsync().WithCancellation(cancellation).ConfigureAwait(false));
}
}
}
}