Add Garnet data protection feature

Author: hishamco

src/OrchardCoreContrib.Garnet/Extensions/GarnetClientExtensions.cs

@@ -36,4 +36,35 @@ public static async Task SetSetAsync(this GarnetClient client, string key, strin
 
         await client.ExecuteForStringResultAsync("SADD", [key, value]);
     }
+
+    /// <summary>
+    /// Gets the values of the specified list key.
+    /// </summary>
+    /// <param name="client">The <see cref="GarnetClient"/>.</param>
+    /// <param name="key">The list key.</param>
+    /// <param name="start">The offset start.</param>
+    /// <param name="stop">The offset stop.</param>
+    /// <returns></returns>
+    public static async Task<string[]> ListRangeAsync(this GarnetClient client, string key, int start, int stop)
+    {
+        Guard.ArgumentNotNull(client, nameof(client));
+
+        return await client.ExecuteForStringArrayResultAsync("LRANGE", [key, start.ToString(), stop.ToString()]);
+    }
+
+    /// <summary>
+    /// Pushes a value to the tail of the list.
+    /// </summary>
+    /// <param name="client">The <see cref="GarnetClient"/>.</param>
+    /// <param name="key">The list key.</param>
+    /// <param name="value">The value to be added.</param>
+    /// <returns></returns>
+    public static async Task ListRightPushAsync(this GarnetClient client, string key, string value)
+    {
+        Guard.ArgumentNotNull(client, nameof(client));
+        Guard.ArgumentNotNullOrEmpty(key, nameof(key));
+        Guard.ArgumentNotNullOrEmpty(value, nameof(value));
+
+        await client.ExecuteForStringResultAsync("RPUSH", [key, value]);
+    }
 }

src/OrchardCoreContrib.Garnet/GarnetKeyManagementOptionsSetup.cs

@@ -0,0 +1,31 @@
+using Microsoft.AspNetCore.DataProtection.KeyManagement;
+using Microsoft.Extensions.Options;
+using OrchardCore.Environment.Shell;
+using OrchardCoreContrib.Garnet.Services;
+
+namespace OrchardCoreContrib.Garnet;
+
+/// <summary>
+/// Represents a setup to configure the <see cref="KeyManagementOptions"/> for Garnet data protection feature.
+/// </summary>
+/// <param name="garnetService">The <see cref="IGarnetService"/>.</param>
+/// <param name="shellSettings">The <see cref="ShellSettings"/>.</param>
+public class GarnetKeyManagementOptionsSetup(IGarnetService garnetService, ShellSettings shellSettings)
+    : IConfigureOptions<KeyManagementOptions>
+{
+    private readonly string _tenant = shellSettings.Name;
+
+    /// <inheritdoc/>
+    public void Configure(KeyManagementOptions options)
+    {
+        options.XmlRepository = new GarnetXmlRepository(() =>
+        {
+            if (garnetService.Client == null)
+            {
+                garnetService.ConnectAsync().GetAwaiter().GetResult();
+            }
+
+            return garnetService.Client;
+        }, $"({garnetService.InstancePrefix}{_tenant}:DataProtection-Keys");
+    }
+}

src/OrchardCoreContrib.Garnet/GarnetXmlRepository.cs

@@ -0,0 +1,35 @@
+using Garnet.client;
+using Microsoft.AspNetCore.DataProtection.Repositories;
+using System.Xml.Linq;
+
+namespace OrchardCoreContrib.Garnet;
+
+/// <summary>
+/// Represents a repository to store data protection keys in Garnet.
+/// </summary>
+/// <param name="garnetClientFactory">The <see cref="GarnetClient"/> factory.</param>
+/// <param name="key">The key.</param>
+public class GarnetXmlRepository(Func<GarnetClient> garnetClientFactory, string key) : IXmlRepository
+{
+    /// <inheritdoc/>
+    public IReadOnlyCollection<XElement> GetAllElements() => GetAllElementsCore().ToList().AsReadOnly();
+
+    /// <inheritdoc/>
+    public void StoreElement(XElement element, string friendlyName) => garnetClientFactory()
+        .ListRightPushAsync(key, element.ToString(SaveOptions.DisableFormatting))
+        .GetAwaiter()
+        .GetResult();
+
+    private IEnumerable<XElement> GetAllElementsCore()
+    {
+        var elements = garnetClientFactory()
+            .ListRangeAsync(key, 0, -1)
+            .GetAwaiter()
+            .GetResult();
+
+        foreach (var element in elements)
+        {
+            yield return XElement.Parse(element);
+        }
+    }
+}

src/OrchardCoreContrib.Garnet/Manifest.cs

@@ -30,3 +30,11 @@
     Dependencies = ["OrchardCoreContrib.Garnet"],
     Category = "Distributed Caching"
 )]
+
+[assembly: Feature(
+    Id = "OrchardCoreContrib.Garnet.DataProtection",
+    Name = "Garnet DataProtection",
+    Description = "Distributed DataProtection using Garnet.",
+    Dependencies = ["OrchardCoreContrib.Garnet"],
+    Category = "Distributed Caching"
+)]

src/OrchardCoreContrib.Garnet/Startups/GarnetDataProtectionStartup.cs

@@ -0,0 +1,23 @@
+using Microsoft.AspNetCore.DataProtection.KeyManagement;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using OrchardCore.Modules;
+using OrchardCoreContrib.Garnet.Services;
+
+namespace OrchardCoreContrib.Garnet;
+
+/// <summary>
+/// Represensts a startup point to register the required services by Garnet data protection feature.
+/// </summary>
+[Feature("OrchardCoreContrib.Garnet.DataProtection")]
+public class GarnetDataProtectionStartup : StartupBase
+{
+    /// <inheritdoc/>
+    public override void ConfigureServices(IServiceCollection services)
+    {
+        if (services.Any(d => d.ServiceType == typeof(IGarnetService)))
+        {
+            services.AddTransient<IConfigureOptions<KeyManagementOptions>, GarnetKeyManagementOptionsSetup>();
+        }
+    }
+}

test/OrchardCoreContrib.Garnet.Tests/Extensions/GarnetClientExtensionsTests.cs

@@ -10,16 +10,20 @@ public class GarnetClientExtensionsTests : TestBase
     public override async Task InitializeAsync()
     {
         _garnetClient = (await Utilities.CreateGarnetServiceAsync()).Client;
-        
-        await _garnetClient.ExecuteForStringResultAsync("SADD", ["sets_key1", "foo", "bar", "baz"]);
-        await _garnetClient.KeyDeleteAsync(["sets_key2"]);
+
+        await _garnetClient.KeyDeleteAsync(["set_key1"]);
+        await _garnetClient.KeyDeleteAsync(["list_key1"]);
+        await _garnetClient.KeyDeleteAsync(["set_key2"]);
+        await _garnetClient.KeyDeleteAsync(["list_key2"]);
+        await _garnetClient.ExecuteForStringResultAsync("SADD", ["set_key1", "foo", "bar", "baz"]);
+        await _garnetClient.ExecuteForStringResultAsync("RPUSH", ["list_key1", "foo", "bar", "baz"]);
     }
 
     [Fact]
     public async Task GetSetElements()
     {
         // Arrange
-        var key = "sets_key1";
+        var key = "set_key1";
 
         // Act
         var values = await _garnetClient.SetGetAsync(key);
@@ -33,7 +37,7 @@ public async Task GetSetElements()
     public async Task AddSetElements()
     {
         // Arrange
-        var key = "sets_key2";
+        var key = "set_key2";
 
         // Act
         await _garnetClient.SetSetAsync(key, "foo");
@@ -44,4 +48,41 @@ public async Task AddSetElements()
         Assert.NotEmpty(values);
         Assert.Equal(["foo", "bar"], values);
     }
+
+    [Theory]
+    [InlineData(0, -1, new string[] { "foo", "bar", "baz" })]
+    [InlineData(0, 0, new string[] { "foo" })]
+    [InlineData(1, 2, new string[] { "bar", "baz" })]
+    [InlineData(-3, 1, new string[] { "foo", "bar" })]
+    [InlineData(-3, 2, new string[] { "foo", "bar", "baz" })]
+    [InlineData(-100, 100, new string[] { "foo", "bar", "baz" })]
+    public async Task GetListElements(int start, int stop, string[] expectedValues)
+    {
+        // Arrange
+        var key = "list_key1";
+
+        // Act
+        var values = await _garnetClient.ListRangeAsync(key, start, stop);
+
+        // Assert
+        Assert.NotEmpty(values);
+        Assert.Equal(expectedValues, values);
+    }
+
+    [Fact]
+    public async Task PushListElement()
+    {
+        // Arrange
+        var key = "list_key2";
+        string[] items = ["foo", "bar"];
+
+        // Act
+        await _garnetClient.ListRightPushAsync(key, items[0]);
+        await _garnetClient.ListRightPushAsync(key, items[1]);
+
+        // Assert
+        var values = await _garnetClient.ExecuteForStringArrayResultAsync("LRANGE", [key, "0", "-1"]);
+        Assert.NotEmpty(values);
+        Assert.Equal(items, values);
+    }
 }

test/OrchardCoreContrib.Garnet.Tests/GarnetXmlRepositoryTests.cs

@@ -0,0 +1,55 @@
+using OrchardCoreContrib.Garnet.Services;
+using System.Xml.Linq;
+
+namespace OrchardCoreContrib.Garnet.Tests;
+
+public class GarnetXmlRepositoryTests : TestBase
+{
+    private static IGarnetService _garnetService;
+
+    public override async Task InitializeAsync()
+    {
+        _garnetService = await Utilities.CreateGarnetServiceAsync();
+
+        await _garnetService.Client.KeyDeleteAsync(["xmlKey1", "xmlKey2", "xmlKey4"]);
+
+        await _garnetService.Client.ExecuteForStringResultAsync("RPUSH", ["xmlKey1", "<element><child1>value1</child1></element>"]);
+
+        for (int i = 1; i <= 3; i++)
+        {
+            await _garnetService.Client.ExecuteForStringResultAsync("RPUSH", ["xmlKey2", "<element><child1>value1</child1></element>"]);
+        }
+    }
+
+    [Theory]
+    [InlineData("xmlKey1", 1)]
+    [InlineData("xmlKey2", 3)]
+    [InlineData("xmlKey3", 0)]
+    public void GetAllElements(string key, int expectedElementsCount)
+    {
+        // Arrange
+        var garnetXmlRepository = new GarnetXmlRepository(() => _garnetService.Client, key);
+
+        // Act
+        var elements = garnetXmlRepository.GetAllElements();
+        
+        // Assert
+        Assert.Equal(expectedElementsCount, elements.Count);
+    }
+
+    [Fact]
+    public void StoreElement()
+    {
+        // Arrange
+        var element = XElement.Parse("<element><child1>value1</child1></element>");
+        var garnetXmlRepository = new GarnetXmlRepository(() => _garnetService.Client, "xmlKey4");
+
+        // Act
+        garnetXmlRepository.StoreElement(element, null);
+
+        // Assert
+        var elements = garnetXmlRepository.GetAllElements();
+        Assert.Single(elements);
+        Assert.Equal(element.ToString(), elements.Single().ToString());
+    }
+}