Content Delivery Network

.gitignore

@@ -7,3 +7,5 @@ riderModule.iml
 .vs/
 .DS_Store
 *.user
+
+src/Argon.Api/storage/

src/Argon.Api/Argon.Api.csproj

@@ -13,6 +13,9 @@
         <PackageReference Include="Aspire.StackExchange.Redis" Version="9.0.0"/>
         <PackageReference Include="Flurl.Http" Version="4.0.2"/>
         <PackageReference Include="Flurl.Http.Newtonsoft" Version="0.9.1"/>
+        <PackageReference Include="Genbox.SimpleS3.Core" Version="3.2.4"/>
+        <PackageReference Include="Genbox.SimpleS3.Extensions.GenericS3" Version="3.2.4"/>
+        <PackageReference Include="Genbox.SimpleS3.Extensions.HttpClient" Version="3.2.4"/>
         <PackageReference Include="MemoryPack" Version="1.21.3"/>
         <PackageReference Include="MessagePipe" Version="1.8.1"/>
         <PackageReference Include="MessagePipe.Analyzer" Version="1.8.1">

src/Argon.Api/Controllers/FilesController.cs

@@ -0,0 +1,74 @@
+namespace Argon.Api.Controllers;
+
+using ActualLab.Collections;
+using Argon.Api.Features.MediaStorage.Storages;
+using Contracts;
+using Features.MediaStorage;
+using Features.Pex;
+using Grains.Interfaces;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+
+public class FilesController(
+    IOptions<CdnOptions> cdnOptions,
+    IContentDeliveryNetwork cdn,
+    IPermissionProvider permissions,
+    IGrainFactory grainFactory) : ControllerBase
+{
+    // work only when cdn\storage set local disk or in memory
+    [HttpGet("/files/{nsPath}/{nsId:guid}/{kind}/{shard}/{fileId}")]
+    public async ValueTask<IActionResult> Files(
+        [FromRoute] string nsPath,
+        [FromRoute] Guid nsId,
+        [FromRoute] string kind,
+        [FromRoute] string shard,
+        [FromRoute] string fileId)
+    {
+        if (cdnOptions.Value.Storage.Kind == StorageKind.GenericS3)
+            return BadRequest();
+
+        var             ns      = new StorageNameSpace(nsPath, nsId);
+        var             assetId = AssetId.FromFileId(fileId);
+        var mem     = DiskContentStorage.OpenFileRead(ns, assetId);
+
+        return File(mem, assetId.GetMime());
+    }
+
+    [HttpPost("/files/server/{serverId:guid}/avatar"), Authorize(JwtBearerDefaults.AuthenticationScheme)]
+    public async ValueTask<IActionResult> UploadServerAvatar([FromRoute] Guid serverId, IFormFile file)
+    {
+        // TODO
+        if (!permissions.CanAccess("server.avatar.upload", PropertyBag.Empty.Set(serverId)))
+            return StatusCode(401);
+        var assetId = AssetId.Avatar();
+        var result  = await cdn.CreateAssetAsync(StorageNameSpace.ForServer(serverId), assetId, file);
+
+        if (result.HasValue)
+            return Ok(result);
+
+        await grainFactory.GetGrain<IServerGrain>(serverId)
+           .UpdateServer(new ServerInput(null, null, assetId.ToFileId()));
+
+        return Ok();
+    }
+
+    [HttpPost("/files/user/{userId:guid}/avatar"), Authorize(JwtBearerDefaults.AuthenticationScheme)]
+    public async ValueTask<IActionResult> UploadUserAvatar([FromRoute] Guid userId, IFormFile file)
+    {
+        // TODO
+        if (!permissions.CanAccess("user.avatar.upload", PropertyBag.Empty.Set(userId)))
+            return StatusCode(401);
+        var assetId = AssetId.Avatar();
+        var result  = await cdn.CreateAssetAsync(StorageNameSpace.ForUser(userId), assetId, file);
+
+        if (result.HasValue)
+            return Ok(result);
+
+        await grainFactory.GetGrain<IUserGrain>(userId)
+           .UpdateUser(new UserEditInput(null, null, assetId.ToFileId()));
+
+        return Ok();
+    }
+}

src/Argon.Api/Controllers/MetadataController.cs

@@ -1,30 +1,26 @@
 namespace Argon.Api.Controllers;
 
+using Extensions;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
 [ApiController]
 public class MetadataController : ControllerBase
 {
     [HttpGet("/cfg.json"), AllowAnonymous]
-    public ValueTask<HeadRoutingConfig> GetHead() => new(new HeadRoutingConfig($"{GlobalVersion.FullSemVer}.{GlobalVersion.ShortSha}",
-        "api.argon.gl", "argon-f14ic5ia.livekit.cloud", [
-            new RegionalNode("cdn-ru1.argon.gl", "ru1"),
-            new RegionalNode("cdn-ru2.argon.gl", "ru1"),
-            new RegionalNode("cdn-as1.argon.gl", "as1")
-        ], [
-            new FeatureFlag("dev.window", true),
-            new FeatureFlag("user.allowServerCreation", true)
-        ]));
+    public ValueTask<HeadRoutingConfig> GetHead()
+        => new(new HeadRoutingConfig($"{GlobalVersion.FullSemVer}.{GlobalVersion.ShortSha}",
+            "api.argon.gl", "argon-f14ic5ia.livekit.cloud", [
+                new FeatureFlag("dev.window", true),
+                new FeatureFlag("user.allowServerCreation", true)
+            ], this.HttpContext.GetRegion()));
 }
 
 public record HeadRoutingConfig(
     string version,
     string masterEndpoint,
     string webRtcEndpoint,
-    List<RegionalNode> cdnAddresses,
-    List<FeatureFlag> features);
-
-public record RegionalNode(string url, string code);
+    List<FeatureFlag> features,
+    string currentRegionCode);
 
 public record FeatureFlag(string code, bool enabled);

src/Argon.Api/Extensions/HttpContextExtensions.cs

@@ -12,6 +12,11 @@ public static string GetRegion(this HttpContext ctx)
             ? ctx.Request.Headers["CF-IPCountry"].ToString()
             : "unknown";
 
+    public static string GetRay(this HttpContext ctx)
+        => ctx.Request.Headers.ContainsKey("CF-Ray")
+            ? ctx.Request.Headers["CF-Ray"].ToString()
+            : $"{Guid.NewGuid()}";
+
     public static string GetClientName(this HttpContext ctx)
         => ctx.Request.Headers.ContainsKey("User-Agent")
             ? ctx.Request.Headers["User-Agent"].ToString()

src/Argon.Api/Features/Jwt/JwtFeature.cs

@@ -1,5 +1,6 @@
 namespace Argon.Api.Features.Jwt;
 
+using Microsoft.AspNetCore.Authentication.JwtBearer;
 using Microsoft.IdentityModel.Tokens;
 
 public static class JwtFeature
@@ -10,7 +11,7 @@ public static IServiceCollection AddJwt(this WebApplicationBuilder builder)
 
         var jwt = builder.Configuration.GetSection("Jwt").Get<JwtOptions>();
 
-        builder.Services.AddSingleton(new TokenValidationParameters
+        var tokenValidator = new TokenValidationParameters
         {
             ValidIssuer              = jwt.Issuer,
             ValidAudience            = jwt.Audience,
@@ -20,8 +21,18 @@ public static IServiceCollection AddJwt(this WebApplicationBuilder builder)
             ValidateLifetime         = true,
             ValidateIssuerSigningKey = true,
             ClockSkew                = TimeSpan.Zero
-        });
+        };
+
+        builder.Services.AddSingleton(tokenValidator);
         builder.Services.AddSingleton<TokenAuthorization>();
+
+        builder.Services.AddAuthentication(options =>
+            {
+                options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+                options.DefaultChallengeScheme    = JwtBearerDefaults.AuthenticationScheme;
+            })
+           .AddJwtBearer((options) => options.TokenValidationParameters = tokenValidator);
+
         return builder.Services;
     }
 }

src/Argon.Api/Features/MediaStorage/AssetId.cs

@@ -0,0 +1,73 @@
+namespace Argon.Api.Features.MediaStorage;
+
+public readonly struct AssetId(Guid assetId, AssetScope scope, AssetKind kind)
+{
+    public string ToFileId()
+        => $"{assetId:D}-{((byte)scope):X2}-{((byte)kind):X2}-00"; // last two zero reserved
+
+    public string GetFilePath()
+    {
+        if (scope == AssetScope.ProfileAsset)
+            return $"profile/{assetId.ToString().Substring(0, 8)}/{ToFileId()}";
+        if (scope == AssetScope.ChatAsset)
+            return $"chat/{assetId.ToString().Substring(0, 8)}/{ToFileId()}";
+        if (scope == AssetScope.ServiceAsset)
+            return $"service/{assetId.ToString().Substring(0, 8)}/{ToFileId()}";
+        return $"temp/{ToFileId()}";
+    }
+
+    public string GetMime()
+        => kind switch
+        {
+            AssetKind.Image          => "image/png",
+            AssetKind.Video          => "video/mp4",
+            AssetKind.VideoNoSound   => "video/mp4",
+            AssetKind.File           => "application/binary",
+            AssetKind.ServerContent  => "application/binary",
+            AssetKind.ServiceContent => "application/binary",
+            AssetKind.Sound          => "application/ogg",
+            _                        => throw new ArgumentOutOfRangeException(nameof(kind), kind, null)
+        };
+    public Dictionary<string, string> GetTags(StorageNameSpace @namespace)
+    {
+        var tags = new Dictionary<string, string>
+        {
+            { nameof(AssetScope), $"{scope}" },
+            { nameof(AssetKind), $"{kind}" },
+            { $"Id", $"{assetId}" },
+            { $"Namespace", $"{@namespace.path}:{@namespace.id}" }
+        };
+        return tags;
+    }
+    public static AssetId FromFileId(string fileId)
+    {
+        if (fileId.Length != 45)
+            throw new InvalidOperationException("Bad file id");
+        var span  = fileId.AsSpan();
+        var guid  = Guid.Parse(span.Slice(0, 36));
+        var scope = byte.Parse(span.Slice(37, 2));
+        var kind  = byte.Parse(span.Slice(40, 2));
+        return new AssetId(guid, (AssetScope)scope, (AssetKind)kind);
+    }
+
+    public static AssetId Avatar()      => new(Guid.NewGuid(), AssetScope.ProfileAsset, AssetKind.Image);
+    public static AssetId VideoAvatar() => new(Guid.NewGuid(), AssetScope.ProfileAsset, AssetKind.VideoNoSound);
+}
+
+public enum AssetScope : byte
+{
+    ProfileAsset,
+    ChatAsset,
+    ServiceAsset
+}
+
+public enum AssetKind : byte
+{
+    Image,
+    Video,        // only png
+    VideoNoSound, // gif
+    File,
+    ServerContent,
+    ServiceContent,
+    Sound
+}

src/Argon.Api/Features/MediaStorage/CdnFeatureExtensions.cs

@@ -0,0 +1,74 @@
+namespace Argon.Api.Features.MediaStorage;
+
+using Storages;
+using Genbox.SimpleS3.Core.Abstracts.Clients;
+using Genbox.SimpleS3.Core.Abstracts.Enums;
+using Genbox.SimpleS3.Core.Common.Authentication;
+using Genbox.SimpleS3.Core.Extensions;
+using Genbox.SimpleS3.Extensions.GenericS3.Extensions;
+using Genbox.SimpleS3.Core.Abstracts.Request;
+using Genbox.SimpleS3.Extensions.HttpClient.Extensions;
+
+public static class CdnFeatureExtensions
+{
+    public static IServiceCollection AddContentDeliveryNetwork(this WebApplicationBuilder builder)
+    {
+        builder.Services.Configure<CdnOptions>(builder.Configuration.GetSection("Cdn"));
+
+        var opt           = builder.Configuration.GetSection("Cdn:Storage");
+        var options       = builder.Services.Configure<StorageOptions>(opt);
+        var bucketOptions = new StorageOptions();
+        opt.Bind(bucketOptions);
+
+
+
+        return bucketOptions.Kind switch
+        {
+            StorageKind.InMemory  => throw new InvalidOperationException(),
+            StorageKind.Disk      => builder.AddContentDeliveryNetwork<DiskContentDeliveryNetwork>(bucketOptions.Kind, bucketOptions),
+            StorageKind.GenericS3 => builder.AddContentDeliveryNetwork<YandexContentDeliveryNetwork>(bucketOptions.Kind, bucketOptions),
+            _                     => throw new ArgumentOutOfRangeException()
+        };
+    }
+
+    public static IServiceCollection AddContentDeliveryNetwork<T>(this WebApplicationBuilder builder, StorageKind keyName, StorageOptions options)
+        where T : class, IContentDeliveryNetwork
+    {
+        if (keyName == StorageKind.Disk)
+        {
+            builder.Services.AddKeyedSingleton<IContentStorage, DiskContentStorage>(IContentStorage.DiskContentStorageKey);
+            builder.Services.AddSingleton<IContentDeliveryNetwork, T>();
+        }
+        if (keyName == StorageKind.GenericS3)
+        {
+            builder.Services.AddKeyedSingleton<IContentStorage, S3ContentStorage>(IContentStorage.GenericS3StorageKey);
+            builder.Services.AddSingleton<IContentDeliveryNetwork, T>();
+            builder.AddS3Storage(keyName, options);
+        }
+
+        return builder.Services;
+    }
+
+
+    public static IServiceCollection AddS3Storage(this WebApplicationBuilder builder, StorageKind keyName, StorageOptions options)
+    {
+        var storageContainer = new ServiceCollection();
+        var coreBuilder      = SimpleS3CoreServices.AddSimpleS3Core(storageContainer);
+        coreBuilder.UseHttpClient();
+        coreBuilder.UseGenericS3(config =>
+        {
+            config.Endpoint    = options.BaseUrl;
+            config.RegionCode  = options.Region;
+            config.Credentials = new StringAccessKey(options.Login, options.Password);
+            config.NamingMode  = NamingMode.PathStyle;
+        });
+
+        var storageServices = storageContainer.BuildServiceProvider();
+
+        builder.Services.AddKeyedSingleton<IServiceProvider>($"{keyName}:container", storageServices);
+        builder.Services.AddKeyedSingleton<IObjectClient>($"{keyName}:client", (services, o)
+            => storageServices.GetRequiredService<IObjectClient>());
+
+        return builder.Services;
+    }
+}

src/Argon.Api/Features/MediaStorage/CdnOptions.cs

@@ -0,0 +1,18 @@
+namespace Argon.Api.Features.MediaStorage;
+
+public class CdnOptions
+{
+    public string         BaseUrl     { get; set; }
+    public TimeSpan       EntryExpire { get; set; }
+    public bool           SignUrl     { get; set; }
+    public string         SignSecret  { get; set; }
+    public StorageOptions Storage     { get; set; }
+}
+
+public readonly record struct StorageSpace(ulong total, ulong current, uint free);
+
+public enum UploadError
+{
+    NONE,
+    INTERNAL_ERROR
+}

src/Argon.Api/Features/MediaStorage/DiskContentDeliveryNetwork.cs

@@ -0,0 +1,28 @@
+namespace Argon.Api.Features.MediaStorage;
+
+using Contracts;
+
+public class DiskContentDeliveryNetwork([FromKeyedServices(IContentStorage.DiskContentStorageKey)] IContentStorage storage,
+    ILogger<YandexContentDeliveryNetwork> logger) : IContentDeliveryNetwork
+{
+    public IContentStorage               Storage { get; } = storage;
+    public async ValueTask<Maybe<UploadError>> CreateAssetAsync(StorageNameSpace ns, AssetId asset, Stream file)
+    {
+        try
+        {
+            await Storage.UploadFile(ns, asset, file);
+            return Maybe<UploadError>.None();
+        }
+        catch (Exception e)
+        {
+            logger.LogCritical(e, $"Failed upload file '{asset.GetFilePath()}'");
+            return UploadError.INTERNAL_ERROR;
+        }
+    }
+
+    public ValueTask<Maybe<UploadError>> ReplaceAssetAsync(StorageNameSpace ns, AssetId asset, Stream file)
+        => throw new NotImplementedException();
+
+    public ValueTask<string> GenerateAssetUrl(StorageNameSpace ns, AssetId asset)
+        => new($"/files/{ns.ToPath()}/{asset.GetFilePath()}?nocache=1");
+}