Add IFeatureService & Related Utilities

extensions/Bitwarden.Extensions.Hosting/examples/MinimalApi/Program.cs

@@ -1,7 +1,21 @@
+using Bitwarden.Extensions.Hosting.Features;
+
 var builder = WebApplication.CreateBuilder(args);
 
 builder.UseBitwardenDefaults();
 
 var app = builder.Build();
 
+app.UseRouting();
+
+app.UseFeatureFlagChecks();
+
+app.MapGet("/", (IConfiguration config) => ((IConfigurationRoot)config).GetDebugView());
+
+app.MapGet("/requires-feature", (IFeatureService featureService) =>
+{
+    return featureService.GetAll();
+})
+    .RequireFeature("feature-one");
+
 app.Run();

extensions/Bitwarden.Extensions.Hosting/examples/MinimalApi/appsettings.Development.json

@@ -4,5 +4,13 @@
       "Default": "Information",
       "Microsoft.AspNetCore": "Warning"
     }
+  },
+  "Features": {
+    "FlagValues": {
+      "feature-one": true,
+      "feature-two": 1,
+      "feature-three": "my-value"
+    },
+    "KnownFlags": ["feature-one", "feature-two"]
   }
 }

extensions/Bitwarden.Extensions.Hosting/src/Attributes/SelfHostedAttribute.cs

@@ -1,4 +1,4 @@
-using Bitwarden.Extensions.Hosting.Exceptions;
+using Bitwarden.Extensions.Hosting.Exceptions;
 using Microsoft.AspNetCore.Mvc.Filters;
 using Microsoft.Extensions.DependencyInjection;
 

extensions/Bitwarden.Extensions.Hosting/src/Bitwarden.Extensions.Hosting.csproj

@@ -22,6 +22,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="LaunchDarkly.ServerSdk" Version="8.5.2" />
     <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.1" />
     <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.9.0" />
     <PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.9.0" />
@@ -43,5 +44,9 @@
   <ItemGroup>
     <None Include=".\README.md" Pack="true" PackagePath="\" />
   </ItemGroup>
-
+
+  <ItemGroup>
+    <InternalsVisibleTo Include="Bitwarden.Extensions.Hosting.Tests" />
+  </ItemGroup>
+
 </Project>

extensions/Bitwarden.Extensions.Hosting/src/BitwardenHostOptions.cs

@@ -1,4 +1,4 @@
-namespace Bitwarden.Extensions.Hosting;
+namespace Bitwarden.Extensions.Hosting;
 
 /// <summary>
 /// Options for configuring the Bitwarden host.

extensions/Bitwarden.Extensions.Hosting/src/Features/FeatureApplicationBuilderExtensions.cs

@@ -0,0 +1,29 @@
+using Bitwarden.Extensions.Hosting.Features;
+
+namespace Microsoft.AspNetCore.Builder;
+
+/// <summary>
+/// Feature extension methods for <see cref="IApplicationBuilder"/>.
+/// </summary>
+public static class FeatureApplicationBuilderExtensions
+{
+    /// <summary>
+    /// Adds the <see cref="FeatureCheckMiddleware"/> to the specified <see cref="IApplicationBuilder"/>, which enabled feature check capabilities.
+    /// <para>
+    /// This call must take place between <c>app.UseRouting()</c> and <c>app.UseEndpoints(...)</c> for middleware to function properly.
+    /// </para>
+    /// </summary>
+    /// <param name="app">The <see cref="IApplicationBuilder"/> to add the middleware to.</param>
+    /// <returns>A reference to <paramref name="app"/> after the operation has completed.</returns>
+    public static IApplicationBuilder UseFeatureFlagChecks(this IApplicationBuilder app)
+    {
+        ArgumentNullException.ThrowIfNull(app);
+
+        // This would be a good time to make sure that IFeatureService is registered but it is a scoped service
+        // and I don't think creating a scope is worth it for that. If we think this is a problem we can add another
+        // marker interface that is registered as a singleton and validate that it exists here.
+
+        app.UseMiddleware<FeatureCheckMiddleware>();
+        return app;
+    }
+}

extensions/Bitwarden.Extensions.Hosting/src/Features/FeatureCheckMiddleware.cs

@@ -0,0 +1,93 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace Bitwarden.Extensions.Hosting.Features;
+
+internal sealed class FeatureCheckMiddleware
+{
+    private readonly RequestDelegate _next;
+    private readonly IHostEnvironment _hostEnvironment;
+    private readonly IProblemDetailsService _problemDetailsService;
+    private readonly ILogger<FeatureCheckMiddleware> _logger;
+
+    public FeatureCheckMiddleware(
+        RequestDelegate next,
+        IHostEnvironment hostEnvironment,
+        IProblemDetailsService problemDetailsService,
+        ILogger<FeatureCheckMiddleware> logger)
+    {
+        ArgumentNullException.ThrowIfNull(next);
+        ArgumentNullException.ThrowIfNull(hostEnvironment);
+        ArgumentNullException.ThrowIfNull(problemDetailsService);
+        ArgumentNullException.ThrowIfNull(logger);
+
+        _next = next;
+        _hostEnvironment = hostEnvironment;
+        _problemDetailsService = problemDetailsService;
+        _logger = logger;
+    }
+
+    public Task Invoke(HttpContext context, IFeatureService featureService)
+    {
+        // This middleware is expected to be placed after `UseRouting()` which will fill in this endpoint
+        var endpoint = context.GetEndpoint();
+
+        if (endpoint == null)
+        {
+            _logger.LogNoEndpointWarning();
+            return _next(context);
+        }
+
+        var featureMetadatas = endpoint.Metadata.GetOrderedMetadata<IFeatureMetadata>();
+
+        foreach (var featureMetadata in featureMetadatas)
+        {
+            if (!featureMetadata.FeatureCheck(featureService))
+            {
+                // Do not execute more of the pipeline, return early.
+                return HandleFailedFeatureCheck(context, featureMetadata);
+            }
+
+            // Continue checking
+        }
+
+        // Either there were no feature checks, or none were failed. Continue on in the pipeline.
+        return _next(context);
+    }
+
+    private async Task HandleFailedFeatureCheck(HttpContext context, IFeatureMetadata failedFeature)
+    {
+        if (_logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogFailedFeatureCheck(failedFeature.ToString()!);
+        }
+
+        context.Response.StatusCode = StatusCodes.Status404NotFound;
+
+        var problemDetails = new ProblemDetails();
+        problemDetails.Title = "Resource not found.";
+        problemDetails.Status = StatusCodes.Status404NotFound;
+
+        // Message added for legacy reasons. We should start preferring title/detail
+        problemDetails.Extensions["Message"] = "Resource not found.";
+
+        // Follow ProblemDetails output type? Would need clients update
+        if (_hostEnvironment.IsDevelopment())
+        {
+            // Add extra information
+            problemDetails.Detail = $"Feature check failed: {failedFeature}";
+        }
+
+        // We don't really care if this fails, we will return the 404 no matter what.
+        await _problemDetailsService.TryWriteAsync(new ProblemDetailsContext
+        {
+            HttpContext = context,
+            ProblemDetails = problemDetails,
+            // TODO: Add metadata?
+        });
+    }
+
+
+}

extensions/Bitwarden.Extensions.Hosting/src/Features/FeatureEndpointConventionBuilderExtensions.cs

@@ -0,0 +1,49 @@
+using Bitwarden.Extensions.Hosting.Features;
+
+namespace Microsoft.AspNetCore.Builder;
+
+/// <summary>
+/// Feature extension methods for <see cref="IEndpointConventionBuilder"/>.
+/// </summary>
+public static class FeatureEndpointConventionBuilderExtensions
+{
+    /// <summary>
+    /// Adds a feature check for the given feature to the endpoint(s).
+    /// </summary>
+    /// <param name="builder">The endpoint convention builder.</param>
+    /// <param name="featureNameKey"></param>
+    /// <returns></returns>
+    public static TBuilder RequireFeature<TBuilder>(this TBuilder builder, string featureNameKey)
+        where TBuilder : IEndpointConventionBuilder
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentNullException.ThrowIfNull(featureNameKey);
+
+        builder.Add(endpointBuilder =>
+        {
+            endpointBuilder.Metadata.Add(new RequireFeatureAttribute(featureNameKey));
+        });
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Adds a feature check with the specified check to the endpoint(s).
+    /// </summary>
+    /// <param name="builder">The endpoint convention builder.</param>
+    /// <param name="featureCheck"></param>
+    /// <returns></returns>
+    public static TBuilder RequireFeature<TBuilder>(this TBuilder builder, Func<IFeatureService, bool> featureCheck)
+        where TBuilder : IEndpointConventionBuilder
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentNullException.ThrowIfNull(featureCheck);
+
+        builder.Add(endpointBuilder =>
+        {
+            endpointBuilder.Metadata.Add(new RequireFeatureAttribute(featureCheck));
+        });
+
+        return builder;
+    }
+}

extensions/Bitwarden.Extensions.Hosting/src/Features/FeatureFlagOptions.cs

@@ -0,0 +1,33 @@
+namespace Bitwarden.Extensions.Hosting.Features;
+
+/// <summary>
+/// A collection of Launch Darkly specific options.
+/// </summary>
+public sealed class LaunchDarklyOptions
+{
+    /// <summary>
+    /// The SdkKey to be used for retrieving feature flag values from Launch Darkly.
+    /// </summary>
+    public string? SdkKey { get; set; }
+}
+
+/// <summary>
+/// A set of options for features.
+/// </summary>
+public sealed class FeatureFlagOptions
+{
+    /// <summary>
+    /// All the flags known to this instance, this is used to enumerable values in <see cref="IFeatureService.GetAll()"/>.
+    /// </summary>
+    public HashSet<string> KnownFlags { get; set; } = new HashSet<string>();
+
+    /// <summary>
+    /// Flags and flag values to include in the feature flag data source.
+    /// </summary>
+    public Dictionary<string, string> FlagValues { get; set; } = new Dictionary<string, string>();
+
+    /// <summary>
+    /// Launch Darkly specific options.
+    /// </summary>
+    public LaunchDarklyOptions LaunchDarkly { get; set; } = new LaunchDarklyOptions();
+}

extensions/Bitwarden.Extensions.Hosting/src/Features/FeatureServiceCollectionExtensions.cs

@@ -0,0 +1,54 @@
+using Bitwarden.Extensions.Hosting.Features;
+
+namespace Microsoft.Extensions.DependencyInjection;
+
+/// <summary>
+/// Extensions for features on <see cref="IServiceCollection"/>.
+/// </summary>
+public static class ServiceCollectionExtensions
+{
+    /// <summary>
+    /// Adds known feature flags to the <see cref="FeatureFlagOptions"/>. This makes these flags
+    /// show up in <see cref="IFeatureService.GetAll()"/>.
+    /// </summary>
+    /// <param name="services">The service collection to customize the options on.</param>
+    /// <param name="knownFlags">The flags to add to the known flags list.</param>
+    /// <returns>The <see cref="IServiceCollection"/> to chain additional calls.</returns>
+    public static IServiceCollection AddKnownFeatureFlags(this IServiceCollection services, IEnumerable<string> knownFlags)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+
+        services.Configure<FeatureFlagOptions>(options =>
+        {
+            foreach (var flag in knownFlags)
+            {
+                options.KnownFlags.Add(flag);
+            }
+        });
+
+        return services;
+    }
+
+    /// <summary>
+    /// Adds feature flags and their values to the <see cref="FeatureFlagOptions"/>.
+    /// </summary>
+    /// <param name="services">The service collection to customize the options on.</param>
+    /// <param name="flagValues">The flags to add to the flag values dictionary.</param>
+    /// <returns>The <see cref="IServiceCollection"/> to chain additional calls. </returns>
+    public static IServiceCollection AddFeatureFlagValues(
+        this IServiceCollection services,
+        IEnumerable<KeyValuePair<string, string>> flagValues)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+
+        services.Configure<FeatureFlagOptions>(options =>
+        {
+            foreach (var flag in flagValues)
+            {
+                options.FlagValues[flag.Key] = flag.Value;
+            }
+        });
+
+        return services;
+    }
+}