osu/osu.Game/Database/UserLookupCache.cs

145 lines
5.3 KiB
C#
Raw Normal View History

2020-11-06 07:38:57 +00:00
// 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;
2020-11-06 07:38:57 +00:00
using osu.Framework.Allocation;
using osu.Game.Online.API;
using osu.Game.Online.API.Requests;
using osu.Game.Users;
namespace osu.Game.Database
{
public class UserLookupCache : MemoryCachingComponent<int, User>
{
[Resolved]
private IAPIProvider api { get; set; }
/// <summary>
/// Perform an API lookup on the specified user, populating a <see cref="User"/> model.
/// </summary>
/// <param name="userId">The user to lookup.</param>
/// <param name="token">An optional cancellation token.</param>
/// <returns>The populated user, or null if the user does not exist or the request could not be satisfied.</returns>
[ItemCanBeNull]
2020-11-09 01:40:16 +00:00
public Task<User> GetUserAsync(int userId, CancellationToken token = default) => GetAsync(userId, token);
2020-11-06 07:38:57 +00:00
/// <summary>
/// Perform an API lookup on the specified users, populating a <see cref="User"/> model.
/// </summary>
/// <param name="userIds">The users to lookup.</param>
/// <param name="token">An optional cancellation token.</param>
/// <returns>The populated users. May include null results for failed retrievals.</returns>
public Task<User[]> GetUsersAsync(int[] userIds, CancellationToken token = default)
{
var userLookupTasks = new List<Task<User>>();
foreach (var u in userIds)
{
userLookupTasks.Add(GetUserAsync(u, token).ContinueWith(task =>
{
if (!task.IsCompletedSuccessfully)
return null;
return task.Result;
}, token));
}
return Task.WhenAll(userLookupTasks);
}
2020-11-06 07:38:57 +00:00
protected override async Task<User> ComputeValueAsync(int lookup, CancellationToken token = default)
=> await queryUser(lookup).ConfigureAwait(false);
2020-11-16 11:52:51 +00:00
private readonly Queue<(int id, TaskCompletionSource<User>)> pendingUserTasks = new Queue<(int, TaskCompletionSource<User>)>();
private Task pendingRequestTask;
private readonly object taskAssignmentLock = new object();
2020-11-06 07:38:57 +00:00
private Task<User> queryUser(int userId)
2020-11-06 07:38:57 +00:00
{
lock (taskAssignmentLock)
{
var tcs = new TaskCompletionSource<User>();
2020-11-06 07:38:57 +00:00
// Add to the queue.
2020-11-16 11:52:51 +00:00
pendingUserTasks.Enqueue((userId, tcs));
2020-11-06 07:38:57 +00:00
// Create a request task if there's not already one.
if (pendingRequestTask == null)
createNewTask();
2020-11-06 07:38:57 +00:00
return tcs.Task;
2020-11-06 07:38:57 +00:00
}
}
private void performLookup()
2020-11-06 07:38:57 +00:00
{
2020-11-17 01:57:11 +00:00
// contains at most 50 unique user IDs from userTasks, which is used to perform the lookup.
var userTasks = new Dictionary<int, List<TaskCompletionSource<User>>>();
// Grab at most 50 unique user IDs from the queue.
2020-11-06 07:38:57 +00:00
lock (taskAssignmentLock)
{
2020-11-17 01:57:11 +00:00
while (pendingUserTasks.Count > 0 && userTasks.Count < 50)
2020-11-06 07:38:57 +00:00
{
2020-11-16 11:52:51 +00:00
(int id, TaskCompletionSource<User> task) next = pendingUserTasks.Dequeue();
// Perform a secondary check for existence, in case the user was queried in a previous batch.
if (CheckExists(next.id, out var existing))
next.task.SetResult(existing);
else
{
2020-11-17 01:57:11 +00:00
if (userTasks.TryGetValue(next.id, out var tasks))
tasks.Add(next.task);
else
userTasks[next.id] = new List<TaskCompletionSource<User>> { next.task };
}
2020-11-06 07:38:57 +00:00
}
}
// Query the users.
2020-11-17 01:57:11 +00:00
var request = new GetUsersRequest(userTasks.Keys.ToArray());
2020-11-06 07:38:57 +00:00
// 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 users to query.
lock (taskAssignmentLock)
{
pendingRequestTask = null;
if (pendingUserTasks.Count > 0)
createNewTask();
2020-11-06 07:38:57 +00:00
}
List<User> foundUsers = request.Result?.Users;
if (foundUsers != null)
2020-11-17 01:57:11 +00:00
{
foreach (var user in foundUsers)
2020-11-17 01:57:11 +00:00
{
if (userTasks.TryGetValue(user.Id, out var tasks))
{
foreach (var task in tasks)
task.SetResult(user);
2020-11-17 01:57:11 +00:00
userTasks.Remove(user.Id);
}
2020-11-17 01:57:11 +00:00
}
}
// if any tasks remain which were not satisfied, return null.
foreach (var tasks in userTasks.Values)
{
foreach (var task in tasks)
task.SetResult(null);
}
2020-11-06 07:38:57 +00:00
}
private void createNewTask() => pendingRequestTask = Task.Run(performLookup);
2020-11-06 07:38:57 +00:00
}
}