remove old ref + update gitsubmodule + update 0.1.0.0 + add NoSnapService + pimpmymod + Licence AGPLv3

MareSynchronos/WebAPI/SignalR/ApiController.cs

@@ -21,10 +21,10 @@ namespace MareSynchronos.WebAPI;
 #pragma warning disable MA0040
 public sealed partial class ApiController : DisposableMediatorSubscriberBase, IMareHubClient
 {
-    public const string UmbraServer = "UmbraSync Main Server (BETA)";
-    public const string UmbraServiceUri = "wss://umbra-sync.net/";
-    public const string UmbraServiceApiUri = "wss://umbra-sync.net/";
-    public const string UmbraServiceHubUri = "wss://umbra-sync.net/mare";  
+        public const string UmbraServer = "Umbra Main Server (BETA)";
+        public const string UmbraServiceUri = "wss://umbra-sync.net";
+        public const string UmbraServiceApiUri = "wss://umbra-sync.net/";
+        public const string UmbraServiceHubUri = "wss://umbra-sync.net/mare";
 
     private readonly DalamudUtilService _dalamudUtil;
     private readonly HubFactory _hubFactory;

MareSynchronos/WebAPI/SignalR/HubFactory.cs

@@ -9,9 +9,6 @@ using Microsoft.AspNetCore.Http.Connections;
 using Microsoft.AspNetCore.SignalR.Client;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using System.Net.Http.Headers;
-using System.Reflection;
-using System.Text.Json;
 
 namespace MareSynchronos.WebAPI.SignalR;
 
@@ -19,6 +16,7 @@ public class HubFactory : MediatorSubscriberBase
 {
     private readonly ILoggerProvider _loggingProvider;
     private readonly ServerConfigurationManager _serverConfigurationManager;
+    private readonly RemoteConfigurationService _remoteConfig;
     private readonly TokenProvider _tokenProvider;
     private HubConnection? _instance;
     private string _cachedConfigFor = string.Empty;
@@ -26,10 +24,11 @@ public class HubFactory : MediatorSubscriberBase
     private bool _isDisposed = false;
 
     public HubFactory(ILogger<HubFactory> logger, MareMediator mediator,
-        ServerConfigurationManager serverConfigurationManager, 
+        ServerConfigurationManager serverConfigurationManager, RemoteConfigurationService remoteConfig,
         TokenProvider tokenProvider, ILoggerProvider pluginLog) : base(logger, mediator)
     {
         _serverConfigurationManager = serverConfigurationManager;
+        _remoteConfig = remoteConfig;
         _tokenProvider = tokenProvider;
         _loggingProvider = pluginLog;
     }
@@ -66,98 +65,28 @@ public class HubFactory : MediatorSubscriberBase
 
     private async Task<HubConnectionConfig> ResolveHubConfig()
     {
-        var stapledWellKnown = _tokenProvider.GetStapledWellKnown(_serverConfigurationManager.CurrentApiUrl);
-
-        var apiUrl = new Uri(_serverConfigurationManager.CurrentApiUrl);
-
-        HubConnectionConfig defaultConfig;
-
         if (_cachedConfig != null && _serverConfigurationManager.CurrentApiUrl.Equals(_cachedConfigFor, StringComparison.Ordinal))
         {
-            defaultConfig = _cachedConfig;
+            return _cachedConfig;
         }
-        else
+        var defaultConfig = new HubConnectionConfig
         {
-            defaultConfig = new HubConnectionConfig
-            {
-                HubUrl = _serverConfigurationManager.CurrentApiUrl.TrimEnd('/') + IMareHub.Path,
-                Transports = []
-            };
-        }
+            HubUrl = _serverConfigurationManager.CurrentApiUrl.TrimEnd('/') + IMareHub.Path,
+            Transports = []
+        };
 
-        string jsonResponse;
-
-        if (stapledWellKnown != null)
+        if (_serverConfigurationManager.CurrentApiUrl.Equals(ApiController.UmbraServiceUri, StringComparison.Ordinal))
         {
-            jsonResponse = stapledWellKnown;
-            Logger.LogTrace("Using stapled hub config for {url}", _serverConfigurationManager.CurrentApiUrl);
-        }
-        else
-        {
-            try
-            {
-                var httpScheme = apiUrl.Scheme.ToLowerInvariant() switch
-                {
-                    "ws" => "http",
-                    "wss" => "https",
-                    _ => apiUrl.Scheme
-                };
-
-                var wellKnownUrl = $"{httpScheme}://{apiUrl.Host}/.well-known/Umbra/client";
-                Logger.LogTrace("Fetching hub config for {uri} via {wk}", _serverConfigurationManager.CurrentApiUrl, wellKnownUrl);
-
-                using var httpClient = new HttpClient(
-                    new HttpClientHandler
-                    {
-                        AllowAutoRedirect = true,
-                        MaxAutomaticRedirections = 5
-                    }
-                );
-
-                var ver = Assembly.GetExecutingAssembly().GetName().Version;
-                httpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("MareSynchronos", ver!.Major + "." + ver!.Minor + "." + ver!.Build));
-
-                var response = await httpClient.GetAsync(wellKnownUrl).ConfigureAwait(false);
-
-                if (!response.IsSuccessStatusCode)
-                    return defaultConfig;
-
-                var contentType = response.Content.Headers.ContentType?.MediaType;
-
-                if (contentType == null || !contentType.Equals("application/json", StringComparison.Ordinal))
-                    return defaultConfig;
-
-                jsonResponse = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
-            }
-            catch (HttpRequestException ex)
-            {
-                Logger.LogWarning(ex, "HTTP request failed for .well-known");
-                return defaultConfig;
-            }
-        }
-
-        try
-        {
-            var config = JsonSerializer.Deserialize<HubConnectionConfig>(jsonResponse);
-
-            if (config == null)
-                return defaultConfig;
-
-            if (string.IsNullOrEmpty(config.ApiUrl))
-                config.ApiUrl = defaultConfig.ApiUrl;
-
-            if (string.IsNullOrEmpty(config.HubUrl))
-                config.HubUrl = defaultConfig.HubUrl;
-
-            config.Transports ??= defaultConfig.Transports ?? [];
-
-            return config;
-        }
-        catch (JsonException ex)
-        {
-            Logger.LogWarning(ex, "Invalid JSON in .well-known response");
-            return defaultConfig;
+            var mainServerConfig = await _remoteConfig.GetConfigAsync<HubConnectionConfig>("mainServer").ConfigureAwait(false) ?? new();
+            if (string.IsNullOrEmpty(mainServerConfig.ApiUrl))
+                mainServerConfig.ApiUrl = ApiController.UmbraServiceApiUri;
+            if (string.IsNullOrEmpty(mainServerConfig.HubUrl))
+                mainServerConfig.HubUrl = ApiController.UmbraServiceHubUri;
+
+            mainServerConfig.Transports ??= defaultConfig.Transports ?? [];
+            return mainServerConfig;
         }
+        return defaultConfig;
     }
 
     private HubConnection BuildHubConnection(HubConnectionConfig hubConfig, CancellationToken ct)
@@ -177,13 +106,11 @@ public class HubFactory : MediatorSubscriberBase
                 var resolver = CompositeResolver.Create(StandardResolverAllowPrivate.Instance,
                     BuiltinResolver.Instance,
                     AttributeFormatterResolver.Instance,
-                    // replace enum resolver
                     DynamicEnumAsStringResolver.Instance,
                     DynamicGenericResolver.Instance,
                     DynamicUnionResolver.Instance,
                     DynamicObjectResolver.Instance,
                     PrimitiveObjectResolver.Instance,
-                    // final fallback(last priority)
                     StandardResolver.Instance);
 
                 opt.SerializerOptions =

MareSynchronos/WebAPI/SignalR/TokenProvider.cs

@@ -20,14 +20,16 @@ public sealed class TokenProvider : IDisposable, IMediatorSubscriber
     private readonly HttpClient _httpClient;
     private readonly ILogger<TokenProvider> _logger;
     private readonly ServerConfigurationManager _serverManager;
+    private readonly RemoteConfigurationService _remoteConfig;
     private readonly ConcurrentDictionary<JwtIdentifier, string> _tokenCache = new();
     private readonly ConcurrentDictionary<string, string?> _wellKnownCache = new(StringComparer.Ordinal);
 
-    public TokenProvider(ILogger<TokenProvider> logger, ServerConfigurationManager serverManager,
+    public TokenProvider(ILogger<TokenProvider> logger, ServerConfigurationManager serverManager, RemoteConfigurationService remoteConfig,
         DalamudUtilService dalamudUtil, MareMediator mareMediator)
     {
         _logger = logger;
         _serverManager = serverManager;
+        _remoteConfig = remoteConfig;
         _dalamudUtil = dalamudUtil;
         _httpClient = new(
             new HttpClientHandler
@@ -68,11 +70,23 @@ public sealed class TokenProvider : IDisposable, IMediatorSubscriber
         Uri tokenUri;
         HttpResponseMessage result;
 
+        var authApiUrl = _serverManager.CurrentApiUrl;
+
+        // Override the API URL used for auth from remote config, if one is available
+        if (authApiUrl.Equals(ApiController.UmbraServiceUri, StringComparison.Ordinal))
+        {
+            var config = await _remoteConfig.GetConfigAsync<HubConnectionConfig>("mainServer").ConfigureAwait(false) ?? new();
+            if (!string.IsNullOrEmpty(config.ApiUrl))
+                authApiUrl = config.ApiUrl;
+            else
+                authApiUrl = ApiController.UmbraServiceApiUri;
+        }
+
         try
         {
             _logger.LogDebug("GetNewToken: Requesting");
 
-            tokenUri = MareAuth.AuthV2FullPath(new Uri(_serverManager.CurrentApiUrl
+            tokenUri = MareAuth.AuthV2FullPath(new Uri(authApiUrl
                 .Replace("wss://", "https://", StringComparison.OrdinalIgnoreCase)
                 .Replace("ws://", "http://", StringComparison.OrdinalIgnoreCase)));
             var secretKey = _serverManager.GetSecretKey(out _)!;