Akavache Version 11 - New version (Breaking Change) (#1040)

* Step 1 Add new code

* Update Akavache.sln

* Ensure All functions have equivalents

* Update

* Refactor InMemoryBlobCache to reside in BSON library

* 4 tests remain to be fixed

* Updated tests

* Update Serializers

* Update SqliteBlobCache.cs

* Improve Serializer handling

* Update DateTime Converters

* Updates for AoT

* Update to resolve path

* Update SettingsCacheTests.cs

* Start to remove verified original code

* Add further tests

* Fix Concurrency in tests

* Add structural folders for tests

* Remove Splat where possible

* Update BlobCacheTestsBase.cs

* Update InMemoryBlobCache instances

* Update SettingsBase.cs

* Add Json Time handlers

* Update Serializers

* Update tests and remove original Akavache

* All tests can pass, some timing issues exist that may mean some fail, tweaking of time tolerances required

* Prepare for final version

* Make single target for settings tests

* Minor Formatting fixes and optimisations

* AOT markup added to missing elements

* Configure Parallellism update tests to be thread safe

* Add comprehensive unit tests and improve test isolation

Added new test files for AOT compatibility, bitmap image extensions, core registrations, and other Akavache features. Enhanced SettingsCacheTests to use unique test names for isolation and added tests for encrypted settings persistence, password validation, multiple disposals, and serializer property management. Updated Akavache.Tests.csproj to reference Akavache.Drawing. Minor fix in LoginExtensions to use value tuple instead of Tuple for login data.

* Update to handle override for database path

* Remove empty tests apps, update tests

* Fix Argument Validation

* Update Insert

* Update Serializer Extension Tests

* Skip some unreliable tests

Author: ChrisPulman

src/Akavache.Benchmarks/.editorconfig

@@ -0,0 +1,5 @@
+# editorconfig.org
+# override for benchmarks.
+
+# top-most EditorConfig file
+root = true

src/Akavache.Benchmarks/Akavache.Benchmarks.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net9.0</TargetFrameworks>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.15.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Akavache.Core\Akavache.Core.csproj" />
+    <ProjectReference Include="..\Akavache.EncryptedSqlite3\Akavache.EncryptedSqlite3.csproj" />
+    <ProjectReference Include="..\Akavache.Sqlite3\Akavache.Sqlite3.csproj" />
+    <ProjectReference Include="..\Akavache.SystemTextJson\Akavache.SystemTextJson.csproj" />
+  </ItemGroup>
+</Project>

src/Akavache.Benchmarks/CacheDatabaseReadBenchmarks.cs

@@ -0,0 +1,171 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reactive.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Jobs;
+
+using Akavache.Core;
+using Akavache.SystemTextJson;
+using System.Reactive.Threading.Tasks;
+
+namespace Akavache.Benchmarks
+{
+    [SimpleJob(RuntimeMoniker.Net90)]
+    [MemoryDiagnoser]
+    [MarkdownExporterAttribute.GitHub]
+    [GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
+    public class CacheDatabaseReadBenchmarks
+    {
+        private readonly Random _randomNumberGenerator = new Random();
+        private string _tempDirectory;
+        private IDisposable _directoryCleanup;
+
+        [Params(10, 100, 1000)] 
+        public int BenchmarkSize { get; set; }
+
+        [GlobalSetup]
+        public void GlobalSetup()
+        {
+            // Initialize the serializer first
+            CoreRegistrations.Serializer = new SystemJsonSerializer();
+            
+            // Create temporary directory
+            _directoryCleanup = Utility.WithEmptyDirectory(out _tempDirectory);
+
+            // Generate database synchronously to avoid deadlocks
+            BlobCache = GenerateAGiantDatabaseSync(_tempDirectory);
+            Keys = BlobCache.GetAllKeys().ToList().FirstAsync().GetAwaiter().GetResult();
+            Size = BenchmarkSize;
+        }
+
+        [GlobalCleanup]
+        public void GlobalCleanup()
+        {
+            BlobCache?.Dispose();
+            _directoryCleanup?.Dispose();
+        }
+
+        public IBlobCache BlobCache { get; set; }
+
+        public int Size { get; set; }
+
+        public IList<string> Keys { get; set; }
+
+        [Benchmark]
+        [BenchmarkCategory("Read")]
+        public async Task SequentialRead()
+        {
+            var toFetch = Enumerable.Range(0, Size)
+                .Select(_ => Keys[_randomNumberGenerator.Next(0, Keys.Count - 1)])
+                .ToArray();
+
+            foreach (var v in toFetch)
+            {
+                await BlobCache.Get(v);
+            }
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("Read")]
+        public async Task RandomRead()
+        {
+            var tasks = new List<Task>();
+            
+            for (int i = 0; i < Size; i++)
+            {
+                var randomKey = Keys[_randomNumberGenerator.Next(0, Keys.Count - 1)];
+                tasks.Add(BlobCache.Get(randomKey).FirstAsync().ToTask());
+            }
+
+            await Task.WhenAll(tasks);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("Read")]
+        public async Task BulkRead()
+        {
+            var toFetch = Enumerable.Range(0, Size)
+                .Select(_ => Keys[_randomNumberGenerator.Next(0, Keys.Count - 1)])
+                .ToArray();
+
+            await BlobCache.Get(toFetch).ToList().FirstAsync();
+        }
+
+        /// <summary>
+        /// Generates a giant database synchronously for GlobalSetup.
+        /// </summary>
+        /// <param name="path">A path to use for generating it.</param>
+        /// <returns>The blob cache.</returns>
+        private IBlobCache GenerateAGiantDatabaseSync(string path)
+        {
+            try
+            {
+                path ??= GetIntegrationTestRootDirectory();
+                
+                var giantDbSize = Math.Max(1000, BenchmarkSize * 10); // Ensure enough data for benchmarks
+                var cache = new Sqlite3.SqliteBlobCache(Path.Combine(path, "benchmarks-read.db"));
+
+                var keys = cache.GetAllKeys().ToList().FirstAsync().GetAwaiter().GetResult();
+                if (keys.Count >= giantDbSize)
+                {
+                    return cache;
+                }
+
+                cache.InvalidateAll().FirstAsync().GetAwaiter().GetResult();
+                
+                // Generate smaller chunks to avoid memory issues
+                var ret = new List<string>();
+                var remaining = giantDbSize;
+                
+                while (remaining > 0)
+                {
+                    var chunkSize = Math.Min(500, remaining); // Process in reasonable chunks
+                    var toWrite = PerfHelper.GenerateRandomDatabaseContents(chunkSize);
+                    
+                    cache.Insert(toWrite).FirstAsync().GetAwaiter().GetResult();
+                    
+                    foreach (var k in toWrite.Keys)
+                    {
+                        ret.Add(k);
+                    }
+                    
+                    remaining -= chunkSize;
+                    
+                    if (remaining % 2000 == 0 || remaining == 0)
+                    {
+                        Console.WriteLine($"Generated {giantDbSize - remaining}/{giantDbSize} items");
+                    }
+                }
+
+                return cache;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error in GenerateAGiantDatabaseSync: {ex.Message}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Gets the root folder for the integration tests.
+        /// </summary>
+        /// <returns>The root folder.</returns>
+        public static string GetIntegrationTestRootDirectory()
+        {
+            // XXX: This is an evil hack, but it's okay for a unit test
+            // We can't use Assembly.Location because unit test runners love
+            // to move stuff to temp directories
+            var st = new StackFrame(true);
+            var di = new DirectoryInfo(Path.Combine(Path.GetDirectoryName(st.GetFileName())));
+
+            return di.FullName;
+        }
+    }
+}

src/Akavache.Benchmarks/Directory.Build.props

@@ -0,0 +1,2 @@
+<Project>
+</Project>

src/Akavache.Benchmarks/PerfHelper.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Akavache.Core;
+
+namespace Akavache.Benchmarks
+{
+    internal static class PerfHelper
+    {
+        private static readonly Random _randomNumberGenerator = new();
+
+        /// <summary>
+        /// Tests generating a database.
+        /// </summary>
+        /// <param name="targetCache">The target blob cache.</param>
+        /// <param name="size">The number of items to generate.</param>
+        /// <returns>A list of generated items.</returns>
+        public static async Task<List<string>> GenerateDatabase(IBlobCache targetCache, int size)
+        {
+            var ret = new List<string>();
+
+            // Write out in groups of 4096
+            while (size > 0)
+            {
+                var toWriteSize = Math.Min(4096, size);
+                var toWrite = GenerateRandomDatabaseContents(toWriteSize);
+
+                await targetCache.Insert(toWrite);
+
+                foreach (var k in toWrite.Keys)
+                {
+                    ret.Add(k);
+                }
+
+                size -= toWrite.Count;
+                Console.WriteLine(size);
+            }
+
+            return ret;
+        }
+
+        /// <summary>
+        /// Generate the contents of the database.
+        /// </summary>
+        /// <param name="toWriteSize">The size of the database to write.</param>
+        /// <returns>A dictionary of the contents.</returns>
+        public static Dictionary<string, byte[]> GenerateRandomDatabaseContents(int toWriteSize)
+        {
+            return Enumerable.Range(0, toWriteSize)
+                .Select(_ => GenerateRandomKey())
+                .Distinct()
+                .ToDictionary(k => k, _ => GenerateRandomBytes());
+        }
+
+        /// <summary>
+        /// Generate random bytes for a value.
+        /// </summary>
+        /// <returns>The generated random bytes.</returns>
+        public static byte[] GenerateRandomBytes()
+        {
+            var ret = new byte[_randomNumberGenerator.Next(1, 256)];
+
+            _randomNumberGenerator.NextBytes(ret);
+            return ret;
+        }
+
+        /// <summary>
+        /// Generates a random key for the database.
+        /// </summary>
+        /// <returns>The random key.</returns>
+        public static string GenerateRandomKey()
+        {
+            var bytes = GenerateRandomBytes();
+
+            // NB: Mask off the MSB and set bit 5 so we always end up with
+            // valid UTF-8 characters that aren't control characters
+            for (int i = 0; i < bytes.Length; i++)
+            {
+                bytes[i] = (byte)((bytes[i] & 0x7F) | 0x20);
+            }
+
+            return Encoding.UTF8.GetString(bytes, 0, Math.Min(256, bytes.Length));
+        }
+
+        /// <summary>
+        /// Gets a series of size values to use in generating performance tests.
+        /// </summary>
+        /// <returns>The range of sizes.</returns>
+        public static int[] GetPerfRanges()
+        {
+            return [1, 10, 100, 1000, 10000, 100000,];
+        }
+    }
+}

src/Akavache.Benchmarks/Program.cs

@@ -0,0 +1,20 @@
+// Copyright (c) 2019-2022 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using BenchmarkDotNet.Running;
+
+namespace Akavache.Benchmarks
+{
+    /// <summary>
+    /// Main entry point class.
+    /// </summary>
+    public static class Program
+    {
+        /// <summary>
+        /// Main entry point.
+        /// </summary>
+        /// <param name="args">Arguments.</param>
+        public static void Main(string[] args) => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
+    }
+}