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;
|
2020-12-28 11:13:24 +00:00
|
|
|
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; }
|
|
|
|
|
2020-12-28 11:05:48 +00:00
|
|
|
/// <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>
|
2020-12-28 11:13:24 +00:00
|
|
|
[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
|
|
|
|
2021-07-05 10:56:16 +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>
|
2021-07-05 12:30:24 +00:00
|
|
|
/// <returns>The populated users. May include null results for failed retrievals.</returns>
|
2021-07-05 10:56:16 +00:00
|
|
|
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)
|
2021-03-08 03:57:16 +00:00
|
|
|
=> await queryUser(lookup).ConfigureAwait(false);
|
2020-11-16 11:35:22 +00:00
|
|
|
|
2020-11-16 11:52:51 +00:00
|
|
|
private readonly Queue<(int id, TaskCompletionSource<User>)> pendingUserTasks = new Queue<(int, TaskCompletionSource<User>)>();
|
2020-11-16 11:35:22 +00:00
|
|
|
private Task pendingRequestTask;
|
|
|
|
private readonly object taskAssignmentLock = new object();
|
2020-11-06 07:38:57 +00:00
|
|
|
|
2020-11-16 11:35:22 +00:00
|
|
|
private Task<User> queryUser(int userId)
|
2020-11-06 07:38:57 +00:00
|
|
|
{
|
|
|
|
lock (taskAssignmentLock)
|
|
|
|
{
|
2020-11-16 11:35:22 +00:00
|
|
|
var tcs = new TaskCompletionSource<User>();
|
2020-11-06 07:38:57 +00:00
|
|
|
|
2020-11-16 11:35:22 +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
|
|
|
|
2020-11-16 11:35:22 +00:00
|
|
|
// Create a request task if there's not already one.
|
|
|
|
if (pendingRequestTask == null)
|
|
|
|
createNewTask();
|
2020-11-06 07:38:57 +00:00
|
|
|
|
2020-11-16 11:35:22 +00:00
|
|
|
return tcs.Task;
|
2020-11-06 07:38:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-16 11:35:22 +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>>>();
|
2020-11-16 11:35:22 +00:00
|
|
|
|
2020-11-16 12:17:43 +00:00
|
|
|
// 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();
|
2020-11-16 11:35:22 +00:00
|
|
|
|
|
|
|
// 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-16 12:17:43 +00:00
|
|
|
{
|
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-16 12:17:43 +00:00
|
|
|
}
|
2020-11-06 07:38:57 +00:00
|
|
|
}
|
2020-11-16 11:35:22 +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
|
|
|
|
2020-11-16 11:35:22 +00:00
|
|
|
// rather than queueing, we maintain our own single-threaded request stream.
|
2020-12-28 05:56:29 +00:00
|
|
|
// todo: we probably want retry logic here.
|
2020-11-16 11:35:22 +00:00
|
|
|
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
|
|
|
}
|
2020-11-16 11:35:22 +00:00
|
|
|
|
2020-12-28 05:56:29 +00:00
|
|
|
List<User> foundUsers = request.Result?.Users;
|
|
|
|
|
|
|
|
if (foundUsers != null)
|
2020-11-17 01:57:11 +00:00
|
|
|
{
|
2020-12-28 05:56:29 +00:00
|
|
|
foreach (var user in foundUsers)
|
2020-11-17 01:57:11 +00:00
|
|
|
{
|
2020-12-28 05:56:29 +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
|
|
|
|
2020-12-28 05:56:29 +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
|
|
|
}
|
2020-11-16 11:35:22 +00:00
|
|
|
|
|
|
|
private void createNewTask() => pendingRequestTask = Task.Run(performLookup);
|
2020-11-06 07:38:57 +00:00
|
|
|
}
|
|
|
|
}
|