New endpoint: /api/v1/meta

Allows you to see the gitlab project info about where the updates come from, mostly useful for RyujinxHelper.

Author: GreemDev

src/Client/Program.cs

@@ -1,6 +1,7 @@
 // This is used for testing the API as it's being made.
 
-/*using Ryujinx.Systems.Update.Client;
+//using System.Text.Json;
+//using Ryujinx.Systems.Update.Client;
 
-var uc = new UpdateClient(UpdateClientConfig.WithAuthorization("redacted"));*/
+//var uc = new UpdateClient(UpdateClientConfig.StandardUnauthorized("http://localhost:5000"));
 

src/Client/UpdateClient/UpdateClient.Meta.cs

@@ -0,0 +1,27 @@
+using System.Net.Http.Json;
+using Ryujinx.Systems.Update.Common;
+
+namespace Ryujinx.Systems.Update.Client;
+
+public partial class UpdateClient
+{
+    /// <summary>
+    ///     Query the sources of the configured version caches on the server. Does not require admin token.
+    /// </summary>
+    /// <returns>A <see cref="Dictionary{string,VersionCacheSource}"/>, or null if any non-200 series HTTP status code is returned from the server.</returns>
+    public async Task<Dictionary<string, VersionCacheSource>?> QueryCacheSourcesAsync()
+    {
+        Log("Checking for cache sources from: {0}", [QualifyUriPath(Constants.FullRouteName_Api_Meta)]);
+
+        var resp = await _http.GetAsync(Constants.FullRouteName_Api_Meta);
+
+        if (!resp.IsSuccessStatusCode)
+        {
+            Log("Received non-success status code ({0}) for cache sources query!",
+                [Enum.GetName(resp.StatusCode) ?? $"{(int)resp.StatusCode}"]);
+            return null;
+        }
+
+        return await resp.Content.ReadFromJsonAsync(JsonSerializerContexts.Default.DictionaryStringVersionCacheSource);
+    }
+}

src/Common/Constants.cs

@@ -18,9 +18,11 @@ internal static class Constants
     public const string RouteName_Download = "download";
     public const string RouteName_Latest = "latest";
     public const string RouteName_Api_Version = "version";
+    public const string RouteName_Api_Meta = "meta";
     public const string RouteName_Api_Admin = "admin";
     public const string RouteName_Api_Admin_RefreshCache = "refresh_cache";
 
+    public const string FullRouteName_Api_Meta = $"{FullApiPrefix}{RouteName_Api_Meta}";
     public const string FullRouteName_Api_Version = $"{FullApiPrefix}{RouteName_Api_Version}";
     public const string FullRouteName_Api_Admin_RefreshCache = $"{FullApiPrefix}{RouteName_Api_Admin}/{RouteName_Api_Admin_RefreshCache}";
 }

src/Common/JsonSerializerContexts.cs

@@ -2,6 +2,9 @@
 
 namespace Ryujinx.Systems.Update.Common;
 
-[JsonSerializable(typeof(VersionCacheEntry))]
-[JsonSerializable(typeof(VersionResponse))]
+[JsonSerializable(typeof(VersionCacheEntry[]))]
+[JsonSerializable(typeof(VersionResponse[]))]
+[JsonSerializable(typeof(IEnumerable<VersionCacheEntry>))]
+[JsonSerializable(typeof(IEnumerable<VersionResponse>))]
+[JsonSerializable(typeof(Dictionary<string, VersionCacheSource>))]
 public partial class JsonSerializerContexts : JsonSerializerContext;

src/Common/Models/VersionCacheSource.cs

@@ -0,0 +1,17 @@
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Systems.Update.Common;
+
+public class VersionCacheSource
+{
+    internal static VersionCacheSource Empty => new()
+    {
+        Id = 0,
+        Owner = string.Empty,
+        Project = string.Empty
+    };
+    
+    [JsonPropertyName("id")] public required long Id { get; set; }
+    [JsonPropertyName("owner")] public required string Owner { get; set; }
+    [JsonPropertyName("project")] public required string Project { get; set; }
+}

src/Server/Controllers/Api/v1/MetaController.cs

@@ -0,0 +1,49 @@
+using Microsoft.AspNetCore.Mvc;
+using Ryujinx.Systems.Update.Common;
+using Ryujinx.Systems.Update.Server.Services.GitLab;
+
+namespace Ryujinx.Systems.Update.Server.Controllers;
+
+[Route($"{Constants.FullRouteName_Api_Meta}")]
+[ApiController]
+public class MetaController : ControllerBase
+{
+    private static readonly Dictionary<string, VersionCacheSource> CacheSources =
+        new(2)
+        {
+            { "stable", VersionCacheSource.Empty },
+            { "canary", VersionCacheSource.Empty }
+        };
+    
+    [HttpGet]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [Produces("application/json")]
+    public async Task<ActionResult<Dictionary<string, VersionCacheSource>>> Action()
+    {
+        var stableCache = HttpContext.RequestServices.GetRequiredKeyedService<VersionCache>("stableCache");
+
+        if (!stableCache.HasProjectInfo)
+            return BadRequest("Stable cache isn't initialized yet.");
+        
+        CacheSources["stable"] = new VersionCacheSource
+        {
+            Id = stableCache.ProjectId,
+            Owner = stableCache.ProjectPath.Split('/')[0],
+            Project = stableCache.ProjectPath.Split('/')[1]
+        };
+        
+        var canaryCache = HttpContext.RequestServices.GetKeyedService<VersionCache>("canaryCache");
+
+        if (canaryCache?.HasProjectInfo ?? false)
+        {
+            CacheSources["canary"] = new VersionCacheSource
+            {
+                Id = canaryCache.ProjectId,
+                Owner = canaryCache.ProjectPath.Split('/')[0],
+                Project = canaryCache.ProjectPath.Split('/')[1]
+            };
+        }
+
+        return Ok(CacheSources);
+    }
+}

src/Server/Services/GitLab/VersionCache.cs

@@ -12,7 +12,13 @@ public class VersionCache : SafeDictionary<string, VersionCacheEntry>
     private readonly ILogger<VersionCache> _logger;
     private readonly PeriodicTimer? _refreshTimer;
 
-    private (string Name, long Id, string Path)? _cachedProject;
+    private Project? _cachedProject;
+
+    public bool HasProjectInfo => _cachedProject != null;
+
+    public string ProjectName => _cachedProject!.NameWithNamespace;
+    public long ProjectId => _cachedProject!.Id;
+    public string ProjectPath => _cachedProject!.PathWithNamespace;
 
     private string? _latestTag;
 
@@ -52,18 +58,13 @@ public VersionCache(IConfiguration config, GitLabService gitlabService, ILogger<
         }
     }
 
-    public string ReleaseUrlFormat => $"{_gitlabEndpoint.TrimEnd('/')}/{_cachedProject!.Value.Path}/-/releases/{{0}}";
+    public string ReleaseUrlFormat => $"{_gitlabEndpoint.TrimEnd('/')}/{ProjectPath}/-/releases/{{0}}";
 
     public void Init(ProjectId projectId) => Executor.ExecuteBackgroundAsync(async () =>
     {
         try
         {
-            if (!_cachedProject.HasValue)
-            {
-                var project = await _gl.Client.Projects.GetAsync(projectId);
-
-                _cachedProject = (project.NameWithNamespace, project.Id, project.PathWithNamespace);
-            }
+            _cachedProject ??= await _gl.Client.Projects.GetAsync(projectId);
         }
         catch (GitLabException e)
         {
@@ -73,7 +74,7 @@ public void Init(ProjectId projectId) => Executor.ExecuteBackgroundAsync(async (
             return;
         }
 
-        _logger.LogInformation("Initializing version cache for {project}", _cachedProject!.Value.Name);
+        _logger.LogInformation("Initializing version cache for {project}", ProjectName);
 
         await RefreshAsync();
 
@@ -85,12 +86,12 @@ public void Init(ProjectId projectId) => Executor.ExecuteBackgroundAsync(async (
 
             _logger.LogInformation(
                 "Periodic version cache refreshing is disabled for {project}. It can be refreshed by {means}",
-                _cachedProject!.Value.Name, howToRefresh);
+                ProjectName, howToRefresh);
             return;
         }
 
         _logger.LogInformation("Refreshing version cache for {project} every {timePeriod} minutes.",
-            _cachedProject!.Value.Name, _refreshTimer.Period.TotalMinutes);
+            ProjectName, _refreshTimer.Period.TotalMinutes);
         while (await _refreshTimer.WaitForNextTickAsync())
         {
             await RefreshAsync();
@@ -111,19 +112,19 @@ public void Init(ProjectId projectId) => Executor.ExecuteBackgroundAsync(async (
 
     public async Task RefreshAsync()
     {
-        _logger.LogInformation("Reloading version cache for {project}", _cachedProject!.Value.Name);
+        _logger.LogInformation("Reloading version cache for {project}", ProjectName);
 
-        _latestTag = (await _gl.GetLatestReleaseAsync(_cachedProject.Value.Id))?.TagName;
+        _latestTag = (await _gl.GetLatestReleaseAsync(ProjectId))?.TagName;
 
         if (_latestTag is null)
         {
-            _logger.LogWarning("Latest version for {project} was a 404, aborting.", _cachedProject.Value.Name);
+            _logger.LogWarning("Latest version for {project} was a 404, aborting.", ProjectName);
             return;
         }
 
         var sw = Stopwatch.StartNew();
 
-        var releases = await _gl.PageReleases(_cachedProject.Value.Id)
+        var releases = await _gl.PageReleases(ProjectId)
             .GetAllAsync(onNonSuccess:
                 code => _logger.LogError(
                     "One of the pagination requests to get all releases returned a non-success status code: {code}",
@@ -178,13 +179,13 @@ public async Task RefreshAsync()
         if (Count > 0)
         {
             _logger.LogInformation("Clearing {entryCount} version cache entries for {project}", Count,
-                _cachedProject!.Value.Name);
+                ProjectName);
             Clear();
         }
 
         foreach (var (tag, entry) in tempCacheEntries)
         {
-            _logger.LogTrace("Adding version cache entry {tag} for {project}", tag, _cachedProject!.Value.Name);
+            _logger.LogTrace("Adding version cache entry {tag} for {project}", tag, ProjectName);
 
             this[tag] = entry;
         }
@@ -196,7 +197,7 @@ public async Task RefreshAsync()
         _semaphore.Release();
 
         _logger.LogInformation("Loaded {entryCount} version cache entries for {project}; took {time}ms.", Count,
-            _cachedProject!.Value.Name, sw.ElapsedMilliseconds);
+            ProjectName, sw.ElapsedMilliseconds);
     }
 
     public static void InitializeVersionCaches(WebApplication app)