wip: introduce file servers to sisk

Author: CypherPotato

cadente/Sisk.Cadente.CoreEngine/CadenteHttpServerEngine.cs

@@ -8,9 +8,7 @@
 // File name:   CadenteHttpServerEngine.cs
 // Repository:  https://github.com/sisk-http/core
 
-using System;
 using System.Net;
-using System.Runtime.InteropServices.JavaScript;
 using System.Threading.Channels;
 using Sisk.Core.Http;
 using Sisk.Core.Http.Engine;

src/Helpers/PathHelper.cs

@@ -15,6 +15,27 @@ namespace Sisk.Core.Helpers;
 /// Provides useful path-dedicated helper members.
 /// </summary>
 public sealed class PathHelper {
+    /// <summary>
+    /// Splits the specified path into its individual segments, removing empty entries and trimming whitespace.
+    /// </summary>
+    /// <param name="path">The path to split.</param>
+    /// <returns>An array of path segments.</returns>
+    public static string [] Split ( string path ) {
+        return path.Split ( [ '/', '\\' ], StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries );
+    }
+
+    /// <summary>
+    /// Removes the last segment from the specified path.
+    /// </summary>
+    /// <param name="path">The path to process.</param>
+    /// <returns>The path without its final segment, or <see cref="string.Empty"/> if no segments remain.</returns>
+    public static string Pop ( string path ) {
+        var segments = Split ( path );
+        if (segments.Length == 0)
+            return string.Empty;
+        return string.Join ( '/', segments, 0, segments.Length - 1 );
+    }
+
     /// <summary>
     /// Combines the specified URL paths into one.
     /// </summary>
@@ -59,11 +80,17 @@ public static string FilesystemCombinePaths ( params string [] paths ) {
     /// </summary>
     /// <param name="path">The path to normalize.</param>
     /// <param name="directorySeparator">The directory separator.</param>
-    public static string NormalizePath ( string path, char directorySeparator = '/' ) {
+    /// <param name="surroundWithDelimiters">
+    /// <see langword="true"/> to ensure the result starts and ends with <paramref name="directorySeparator"/>;
+    /// otherwise, <see langword="false"/>. Defaults to <see langword="false"/>.
+    /// </param>
+    public static string NormalizePath ( string path, char directorySeparator = '/', bool surroundWithDelimiters = false ) {
         string [] parts = path.Split ( pathNormalizationChars, StringSplitOptions.RemoveEmptyEntries );
         string result = string.Join ( directorySeparator, parts );
         if (path.StartsWith ( '/' ) || path.StartsWith ( '\\' ))
             result = directorySeparator + result;
+        if (surroundWithDelimiters)
+            result = directorySeparator + result.Trim ( '/', '\\' ) + directorySeparator;
         return result;
     }
 }

src/Http/FileContent.cs

@@ -0,0 +1,104 @@
+// The Sisk Framework source code
+// Copyright (c) 2024- PROJECT PRINCIPIUM and all Sisk contributors
+//
+// The code below is licensed under the MIT license as
+// of the date of its publication, available at
+//
+// File name:   FileContent.cs
+// Repository:  https://github.com/sisk-http/core
+
+using System.Net;
+using Sisk.Core.Helpers;
+
+namespace Sisk.Core.Http;
+
+/// <summary>
+/// Provides HTTP content based on a file.
+/// </summary>
+public sealed class FileContent : HttpContent {
+
+    const string DefaultMimeType = "application/octet-stream";
+
+    /// <summary>
+    /// Gets the file information for the content.
+    /// </summary>
+    public FileInfo File { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FileContent"/> class with the specified file.
+    /// </summary>
+    /// <param name="file">The file to be used as content.</param>
+    public FileContent ( FileInfo file ) {
+        File = file;
+
+        var mimeType = MimeHelper.GetMimeType ( File.Extension, DefaultMimeType );
+        if (mimeType == DefaultMimeType) {
+            Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue ( "attachment" ) {
+                FileName = File.Name
+            };
+        }
+        else {
+            Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue ( "inline" );
+        }
+
+        Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue ( mimeType );
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FileContent"/> class with the specified file path.
+    /// </summary>
+    /// <param name="filePath">The path to the file to be used as content.</param>
+    public FileContent ( string filePath ) : this ( new FileInfo ( filePath ) ) {
+    }
+
+    void ThrowIfFileNotFound () {
+        if (!File.Exists)
+            throw new FileNotFoundException ( "The specified file was not found.", File.FullName );
+    }
+
+    /// <inheritdoc/>
+    protected override async Task SerializeToStreamAsync ( Stream stream, TransportContext? context, CancellationToken cancellationToken ) {
+        ThrowIfFileNotFound ();
+
+        using var fs = File.OpenRead ();
+        await fs.CopyToAsync ( stream, cancellationToken );
+    }
+
+    /// <inheritdoc/>
+    protected override Task SerializeToStreamAsync ( Stream stream, TransportContext? context ) {
+        return SerializeToStreamAsync ( stream, context, default );
+    }
+
+    /// <inheritdoc/>
+    protected override void SerializeToStream ( Stream stream, TransportContext? context, CancellationToken cancellationToken ) {
+        ThrowIfFileNotFound ();
+
+        using var fs = File.OpenRead ();
+        fs.CopyTo ( stream );
+    }
+
+    /// <inheritdoc/>
+    protected override Stream CreateContentReadStream ( CancellationToken cancellationToken ) {
+        ThrowIfFileNotFound ();
+
+        return File.OpenRead ();
+    }
+
+    /// <inheritdoc/>
+    protected override Task<Stream> CreateContentReadStreamAsync () {
+        return Task.FromResult ( CreateContentReadStream ( default ) );
+    }
+
+    /// <inheritdoc/>
+    protected override Task<Stream> CreateContentReadStreamAsync ( CancellationToken cancellationToken ) {
+        return Task.FromResult ( CreateContentReadStream ( cancellationToken ) );
+    }
+
+    /// <inheritdoc/>
+    protected override bool TryComputeLength ( out long length ) {
+        ThrowIfFileNotFound ();
+
+        length = File.Length;
+        return true;
+    }
+}

src/Http/FileSystem/Converters/HttpFileAudioConverter.cs

@@ -0,0 +1,19 @@
+// The Sisk Framework source code
+// Copyright (c) 2024- PROJECT PRINCIPIUM and all Sisk contributors
+//
+// The code below is licensed under the MIT license as
+// of the date of its publication, available at
+//
+// File name:   HttpFileAudioConverter.cs
+// Repository:  https://github.com/sisk-http/core
+
+namespace Sisk.Core.Http.FileSystem.Converters;
+
+internal class HttpFileAudioConverter : HttpFileRangedContentStream {
+
+    static string [] AllowedExtensions = [ ".mp3", ".ogg", ".wav", ".flac", ".ogv" ];
+
+    public override bool CanConvert ( FileInfo file ) {
+        return AllowedExtensions.Contains ( file.Extension.ToLowerInvariant () );
+    }
+}

src/Http/FileSystem/Converters/HttpFileRangedContentStream.cs

@@ -0,0 +1,199 @@
+// The Sisk Framework source code
+// Copyright (c) 2024- PROJECT PRINCIPIUM and all Sisk contributors
+//
+// The code below is licensed under the MIT license as
+// of the date of its publication, available at
+//
+// File name:   HttpFileRangedContentStream.cs
+// Repository:  https://github.com/sisk-http/core
+
+using System.Buffers;
+using System.Globalization;
+using System.Net;
+using Sisk.Core.Helpers;
+using Sisk.Core.Http;
+using Sisk.Core.Http.FileSystem;
+
+abstract class HttpFileRangedContentStream : HttpFileServerFileConverter {
+
+    public virtual int ChunkSize => 5 * (int) SizeHelper.UnitMb;
+
+    public override HttpResponse Convert ( FileInfo file, HttpRequest request ) {
+
+        ArgumentOutOfRangeException.ThrowIfNegativeOrZero ( ChunkSize );
+
+        using var fs = file.OpenRead ();
+        long length = fs.Length;
+
+        string? rangeHeader = request.Headers.Range;
+
+        bool hasRange = TryGetSingleRange (
+            rangeHeader,
+            length,
+            out long rangeStart,
+            out long rangeEnd,
+            out bool isRangeSatisfiable
+        );
+
+        if (hasRange && !isRangeSatisfiable) {
+            return new HttpResponse ( HttpStatusCode.RequestedRangeNotSatisfiable )
+                .WithHeader ( HttpKnownHeaderNames.ContentRange, $"bytes */{length}" );
+        }
+
+        if (!hasRange) {
+            var resStream = request.GetResponseStream ();
+
+            resStream.SetStatus ( HttpStatusCode.OK );
+            resStream.SetHeader ( HttpKnownHeaderNames.AcceptRanges, "bytes" );
+            resStream.SetHeader ( HttpKnownHeaderNames.ContentType, MimeHelper.GetMimeType ( file.Extension ) );
+            resStream.SetContentLength ( length );
+
+            var buffer = ArrayPool<byte>.Shared.Rent ( ChunkSize );
+            try {
+                int read;
+                while ((read = fs.Read ( buffer, 0, buffer.Length )) > 0) {
+                    resStream.ResponseStream.Write ( buffer, 0, read );
+                }
+            }
+            finally {
+                ArrayPool<byte>.Shared.Return ( buffer );
+            }
+
+            return resStream.Close ();
+        }
+
+        long requestedLength = rangeEnd - rangeStart + 1;
+
+        long maxLength = ChunkSize > 0
+            ? Math.Min ( requestedLength, ChunkSize )
+            : requestedLength;
+
+        long actualEnd = rangeStart + maxLength - 1;
+
+        var partialResStream = request.GetResponseStream ();
+
+        partialResStream.SetStatus ( HttpStatusCode.PartialContent );
+        partialResStream.SetHeader ( HttpKnownHeaderNames.AcceptRanges, "bytes" );
+        partialResStream.SetHeader ( HttpKnownHeaderNames.ContentType, MimeHelper.GetMimeType ( file.Extension ) );
+        partialResStream.SetHeader (
+            HttpKnownHeaderNames.ContentRange,
+            $"bytes {rangeStart}-{actualEnd}/{length}"
+        );
+        partialResStream.SetContentLength ( maxLength );
+
+        fs.Position = rangeStart;
+
+        // Buffer de leitura (no máximo ChunkSize, e nunca mais do que o que falta enviar)
+        var rangeBuffer = ArrayPool<byte>.Shared.Rent ( (int) Math.Min ( ChunkSize, maxLength ) );
+        try {
+            long remaining = maxLength;
+            while (remaining > 0) {
+                int read = fs.Read ( rangeBuffer, 0, (int) Math.Min ( rangeBuffer.Length, remaining ) );
+                if (read <= 0)
+                    break;
+
+                if (request.Method != HttpMethod.Head)
+                    partialResStream.ResponseStream.Write ( rangeBuffer, 0, read );
+                remaining -= read;
+            }
+        }
+        finally {
+            ArrayPool<byte>.Shared.Return ( rangeBuffer );
+        }
+
+        return partialResStream.Close ();
+    }
+
+    private static bool TryGetSingleRange ( string? rangeHeader, long entityLength, out long rangeStart, out long rangeEnd, out bool isSatisfiable ) {
+        rangeStart = 0;
+        rangeEnd = 0;
+        isSatisfiable = false;
+
+        if (string.IsNullOrWhiteSpace ( rangeHeader ))
+            return false;
+
+        rangeHeader = rangeHeader.Trim ();
+
+        if (!rangeHeader.StartsWith ( "bytes=", StringComparison.OrdinalIgnoreCase ))
+            return false;
+
+        var rangeSpec = rangeHeader.Substring ( "bytes=".Length ).Trim ();
+        if (string.IsNullOrEmpty ( rangeSpec ))
+            return false;
+
+        if (rangeSpec.Contains ( ',' ))
+            return false;
+
+        var parts = rangeSpec.Split ( '-', 2 );
+        if (parts.Length != 2)
+            return false;
+
+        string startPart = parts [ 0 ].Trim ();
+        string endPart = parts [ 1 ].Trim ();
+
+        // Caso 1: bytes=start-end
+        if (startPart.Length > 0 && endPart.Length > 0) {
+            if (!long.TryParse ( startPart, NumberStyles.None, CultureInfo.InvariantCulture, out var start ) ||
+                !long.TryParse ( endPart, NumberStyles.None, CultureInfo.InvariantCulture, out var end )) {
+                return false;
+            }
+
+            if (start < 0 || end < start)
+                return false;
+
+            if (start >= entityLength) {
+                isSatisfiable = false;
+                return true;
+            }
+
+            rangeStart = start;
+            rangeEnd = Math.Min ( end, entityLength - 1 );
+            isSatisfiable = true;
+            return true;
+        }
+
+        if (startPart.Length > 0 && endPart.Length == 0) {
+            if (!long.TryParse ( startPart, NumberStyles.None, CultureInfo.InvariantCulture, out var start ))
+                return false;
+
+            if (start < 0)
+                return false;
+
+            if (start >= entityLength) {
+                isSatisfiable = false;
+                return true;
+            }
+
+            rangeStart = start;
+            rangeEnd = entityLength - 1;
+            isSatisfiable = true;
+            return true;
+        }
+
+        if (startPart.Length == 0 && endPart.Length > 0) {
+            if (!long.TryParse ( endPart, NumberStyles.None, CultureInfo.InvariantCulture, out var suffixLength ))
+                return false;
+
+            if (suffixLength <= 0)
+                return false;
+
+            if (entityLength == 0) {
+                isSatisfiable = false;
+                return true;
+            }
+
+            if (suffixLength >= entityLength) {
+                rangeStart = 0;
+            }
+            else {
+                rangeStart = entityLength - suffixLength;
+            }
+
+            rangeEnd = entityLength - 1;
+            isSatisfiable = true;
+            return true;
+        }
+
+        return false;
+    }
+}