1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-20 01:32:56 +08:00
osu-lazer/osu.Game/Database/BeatmapLookupCache.cs

150 lines
5.9 KiB
C#

// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using JetBrains.Annotations;
using osu.Framework.Allocation;
using osu.Game.Online.API;
using osu.Game.Online.API.Requests;
using osu.Game.Online.API.Requests.Responses;
namespace osu.Game.Database
{
// This class is based on `UserLookupCache` which is well tested.
// If modifications are to be made here, a base abstract implementation should likely be created and shared between the two.
public class BeatmapLookupCache : MemoryCachingComponent<int, APIBeatmap>
{
[Resolved]
private IAPIProvider api { get; set; }
/// <summary>
/// Perform an API lookup on the specified beatmap, populating a <see cref="APIBeatmap"/> model.
/// </summary>
/// <param name="beatmapId">The beatmap to lookup.</param>
/// <param name="token">An optional cancellation token.</param>
/// <returns>The populated beatmap, or null if the beatmap does not exist or the request could not be satisfied.</returns>
[ItemCanBeNull]
public Task<APIBeatmap> GetBeatmapAsync(int beatmapId, CancellationToken token = default) => GetAsync(beatmapId, token);
/// <summary>
/// Perform an API lookup on the specified beatmaps, populating a <see cref="APIBeatmap"/> model.
/// </summary>
/// <param name="beatmapIds">The beatmaps to lookup.</param>
/// <param name="token">An optional cancellation token.</param>
/// <returns>The populated beatmaps. May include null results for failed retrievals.</returns>
public Task<APIBeatmap[]> GetBeatmapsAsync(int[] beatmapIds, CancellationToken token = default)
{
var beatmapLookupTasks = new List<Task<APIBeatmap>>();
foreach (int u in beatmapIds)
{
beatmapLookupTasks.Add(GetBeatmapAsync(u, token).ContinueWith(task =>
{
if (!task.IsCompletedSuccessfully)
return null;
return task.Result;
}, token));
}
return Task.WhenAll(beatmapLookupTasks);
}
protected override async Task<APIBeatmap> ComputeValueAsync(int lookup, CancellationToken token = default)
=> await queryBeatmap(lookup).ConfigureAwait(false);
private readonly Queue<(int id, TaskCompletionSource<APIBeatmap>)> pendingBeatmapTasks = new Queue<(int, TaskCompletionSource<APIBeatmap>)>();
private Task pendingRequestTask;
private readonly object taskAssignmentLock = new object();
private Task<APIBeatmap> queryBeatmap(int beatmapId)
{
lock (taskAssignmentLock)
{
var tcs = new TaskCompletionSource<APIBeatmap>();
// Add to the queue.
pendingBeatmapTasks.Enqueue((beatmapId, tcs));
// Create a request task if there's not already one.
if (pendingRequestTask == null)
createNewTask();
return tcs.Task;
}
}
private void performLookup()
{
// contains at most 50 unique beatmap IDs from beatmapTasks, which is used to perform the lookup.
var beatmapTasks = new Dictionary<int, List<TaskCompletionSource<APIBeatmap>>>();
// Grab at most 50 unique beatmap IDs from the queue.
lock (taskAssignmentLock)
{
while (pendingBeatmapTasks.Count > 0 && beatmapTasks.Count < 50)
{
(int id, TaskCompletionSource<APIBeatmap> task) next = pendingBeatmapTasks.Dequeue();
// Perform a secondary check for existence, in case the beatmap was queried in a previous batch.
if (CheckExists(next.id, out var existing))
next.task.SetResult(existing);
else
{
if (beatmapTasks.TryGetValue(next.id, out var tasks))
tasks.Add(next.task);
else
beatmapTasks[next.id] = new List<TaskCompletionSource<APIBeatmap>> { next.task };
}
}
}
if (beatmapTasks.Count == 0)
return;
// Query the beatmaps.
var request = new GetBeatmapsRequest(beatmapTasks.Keys.ToArray());
// rather than queueing, we maintain our own single-threaded request stream.
// todo: we probably want retry logic here.
api.Perform(request);
// Create a new request task if there's still more beatmaps to query.
lock (taskAssignmentLock)
{
pendingRequestTask = null;
if (pendingBeatmapTasks.Count > 0)
createNewTask();
}
List<APIBeatmap> foundBeatmaps = request.Response?.Beatmaps;
if (foundBeatmaps != null)
{
foreach (var beatmap in foundBeatmaps)
{
if (beatmapTasks.TryGetValue(beatmap.OnlineID, out var tasks))
{
foreach (var task in tasks)
task.SetResult(beatmap);
beatmapTasks.Remove(beatmap.OnlineID);
}
}
}
// if any tasks remain which were not satisfied, return null.
foreach (var tasks in beatmapTasks.Values)
{
foreach (var task in tasks)
task.SetResult(null);
}
}
private void createNewTask() => pendingRequestTask = Task.Run(performLookup);
}
}