diff --git a/EasyCaching.sln b/EasyCaching.sln index 7d07ad0a..55b18b3b 100644 --- a/EasyCaching.sln +++ b/EasyCaching.sln @@ -1,4 +1,5 @@ -Microsoft Visual Studio Solution File, Format Version 12.00 + +Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.2.32616.157 MinimumVisualStudioVersion = 10.0.40219.1 @@ -72,11 +73,13 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EasyCaching.Serialization.S EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EasyCaching.Bus.ConfluentKafka", "bus\EasyCaching.Bus.ConfluentKafka\EasyCaching.Bus.ConfluentKafka.csproj", "{F7FBADEB-D766-4595-949A-07104B52692C}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EasyCaching.Bus.Zookeeper", "bus\EasyCaching.Bus.Zookeeper\EasyCaching.Bus.Zookeeper.csproj", "{5E488583-391E-4E15-83C1-7301B4FE79AE}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EasyCaching.Bus.Zookeeper", "bus\EasyCaching.Bus.Zookeeper\EasyCaching.Bus.Zookeeper.csproj", "{5E488583-391E-4E15-83C1-7301B4FE79AE}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EasyCaching.FasterKv", "src\EasyCaching.FasterKv\EasyCaching.FasterKv.csproj", "{7191E567-38DF-4879-82E1-73EC618AFCAC}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EasyCaching.FasterKv", "src\EasyCaching.FasterKv\EasyCaching.FasterKv.csproj", "{7191E567-38DF-4879-82E1-73EC618AFCAC}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EasyCaching.Serialization.MemoryPack", "serialization\EasyCaching.Serialization.MemoryPack\EasyCaching.Serialization.MemoryPack.csproj", "{EEF22C21-F380-4980-B72C-F14488369333}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EasyCaching.Serialization.MemoryPack", "serialization\EasyCaching.Serialization.MemoryPack\EasyCaching.Serialization.MemoryPack.csproj", "{EEF22C21-F380-4980-B72C-F14488369333}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EasyCaching.Etcd", "src\EasyCaching.Etcd\EasyCaching.Etcd.csproj", "{984B7E9C-B8C3-4C01-BBC2-345AF28FCC11}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -208,6 +211,10 @@ Global {EEF22C21-F380-4980-B72C-F14488369333}.Debug|Any CPU.Build.0 = Debug|Any CPU {EEF22C21-F380-4980-B72C-F14488369333}.Release|Any CPU.ActiveCfg = Release|Any CPU {EEF22C21-F380-4980-B72C-F14488369333}.Release|Any CPU.Build.0 = Release|Any CPU + {984B7E9C-B8C3-4C01-BBC2-345AF28FCC11}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {984B7E9C-B8C3-4C01-BBC2-345AF28FCC11}.Debug|Any CPU.Build.0 = Debug|Any CPU + {984B7E9C-B8C3-4C01-BBC2-345AF28FCC11}.Release|Any CPU.ActiveCfg = Release|Any CPU + {984B7E9C-B8C3-4C01-BBC2-345AF28FCC11}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -244,6 +251,7 @@ Global {5E488583-391E-4E15-83C1-7301B4FE79AE} = {B337509B-75F9-4851-821F-9BBE87C4E4BC} {7191E567-38DF-4879-82E1-73EC618AFCAC} = {A0F5CC7E-155F-4726-8DEB-E966950B3FE9} {EEF22C21-F380-4980-B72C-F14488369333} = {15070C49-A507-4844-BCFE-D319CFBC9A63} + {984B7E9C-B8C3-4C01-BBC2-345AF28FCC11} = {A0F5CC7E-155F-4726-8DEB-E966950B3FE9} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {63A57886-054B-476C-AAE1-8D7C8917682E} diff --git a/README.md b/README.md index 266053d8..97c71485 100644 --- a/README.md +++ b/README.md @@ -95,6 +95,7 @@ public class Startup config.DBConfig.Endpoints.Add(new ServerEndPoint("127.0.0.1", 6379)); }, "redis1") .WithMessagePack()//with messagepack serialization + .UseRedisLock()//with distributed lock ; }); } diff --git a/build/releasenotes.props b/build/releasenotes.props index 5cba50e4..d1a12da0 100644 --- a/build/releasenotes.props +++ b/build/releasenotes.props @@ -72,5 +72,8 @@ 1. Upgrading dependencies. + + 1. Add etcd module. + diff --git a/build/version.props b/build/version.props index 8cadff5e..d595021e 100644 --- a/build/version.props +++ b/build/version.props @@ -24,5 +24,6 @@ 1.9.0 1.9.0 1.9.0 + 1.9.0 diff --git a/bus/EasyCaching.Bus.Zookeeper/Configurations/ZookeeperOptionsExtension.cs b/bus/EasyCaching.Bus.Zookeeper/Configurations/ZookeeperOptionsExtension.cs index 901ff238..6e4b957b 100644 --- a/bus/EasyCaching.Bus.Zookeeper/Configurations/ZookeeperOptionsExtension.cs +++ b/bus/EasyCaching.Bus.Zookeeper/Configurations/ZookeeperOptionsExtension.cs @@ -33,4 +33,4 @@ public void AddServices(IServiceCollection services) services.AddSingleton(); } } -} \ No newline at end of file +} diff --git a/docs/Etcd.md b/docs/Etcd.md new file mode 100644 index 00000000..0d64c376 --- /dev/null +++ b/docs/Etcd.md @@ -0,0 +1,86 @@ +# DefaultEtcdCachingProvider + +Etcd is a hybrid memory and disk Kv Store, so it can support much larger data storage than memory. + +EasyCaching.Etcd is a lib that is based on **EasyCaching.Core** and **dotnet-etcd-core**. + + +# How to use ? + +## 1. Install the package via Nuget + +``` +Install-Package EasyCaching.Etcd +``` + +## 2. Config in Startup class + +```csharp +public class Startup +{ + //... + + public void ConfigureServices(IServiceCollection services) + { + services.AddMvc(); + + services.AddEasyCaching(option => + { + //use Etcd cache + option.UseEtcd(config => + { + config.Address = "http://127.0.0.1:2379"; + config.Timeout = 30000; + // Etcd must be set SerializerName + config.SerializerName = "msg"; + }) + .WithMessagePack("msg"); + }); + } +} +``` + +### 3. Call the EasyCachingProvider + +The following code show how to use EasyCachingProvider in ASP.NET Core Web API. + +```csharp +[Route("api/[controller]")] +public class ValuesController : Controller +{ + private readonly IEasyCachingProvider _provider; + + public ValuesController(IEasyCachingProvider provider) + { + this._provider = provider; + } + + [HttpGet] + public string Get() + { + //Remove + _provider.Remove("demo"); + + //Set + _provider.Set("demo", "123", TimeSpan.FromMinutes(1)); + + //Get + var res = _provider.Get("demo", () => "456", TimeSpan.FromMinutes(1)); + + //Get without data retriever + var res = _provider.Get("demo"); + + //Remove Async + await _provider.RemoveAsync("demo"); + + //Set Async + await _provider.SetAsync("demo", "123", TimeSpan.FromMinutes(1)); + + //Get Async + var res = await _provider.GetAsync("demo",async () => await Task.FromResult("456"), TimeSpan.FromMinutes(1)); + + //Get without data retriever Async + var res = await _provider.GetAsync("demo"); + } +} +``` diff --git a/docs/Hybrid.md b/docs/Hybrid.md index 3552a2eb..fc1196fb 100644 --- a/docs/Hybrid.md +++ b/docs/Hybrid.md @@ -19,6 +19,7 @@ Install-Package EasyCaching.HybridCache Install-Package EasyCaching.InMemory Install-Package EasyCaching.Redis Install-Package EasyCaching.Bus.Redis +Install-Package EasyCaching.Serialization.Json ``` ## 2. Config in Startup class @@ -41,7 +42,7 @@ public class Startup // distributed option.UseRedis(config => { - config.DBConfig.Endpoints.Add(new Core.Configurations.ServerEndPoint("127.0.0.1", 6379)); + config.DBConfig.Endpoints.Add(new ServerEndPoint("127.0.0.1", 6379)); config.DBConfig.Database = 5; config.SerializerName = "myjson"; }, "myredis"); diff --git a/mkdocs.yml b/mkdocs.yml index ca4bb888..26e4965b 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -15,6 +15,7 @@ pages: - Disk : Disk.md - LiteDB : LiteDB.md - FasterKv: FasterKv.md + - Etcd: Etcd.md # - ProviderFactory : ProviderFactory.md - Provider Factory: - Overview : FactoryOverview.md diff --git a/sample/EasyCaching.Demo.ConsoleApp/EasyCaching.Demo.ConsoleApp.csproj b/sample/EasyCaching.Demo.ConsoleApp/EasyCaching.Demo.ConsoleApp.csproj index 61cbb702..f9d4a7a4 100644 --- a/sample/EasyCaching.Demo.ConsoleApp/EasyCaching.Demo.ConsoleApp.csproj +++ b/sample/EasyCaching.Demo.ConsoleApp/EasyCaching.Demo.ConsoleApp.csproj @@ -14,6 +14,7 @@ + diff --git a/sample/EasyCaching.Demo.ConsoleApp/Program.cs b/sample/EasyCaching.Demo.ConsoleApp/Program.cs index ccb3f2e1..4fc83d4c 100644 --- a/sample/EasyCaching.Demo.ConsoleApp/Program.cs +++ b/sample/EasyCaching.Demo.ConsoleApp/Program.cs @@ -6,10 +6,13 @@ namespace EasyCaching.Demo.ConsoleApp using EasyCaching.Disk; using EasyCaching.Serialization.SystemTextJson.Configurations; using EasyCaching.SQLite; + using Google.Protobuf.WellKnownTypes; using MemoryPack; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Options; + using Newtonsoft.Json; using System; + using System.Collections.Generic; using System.IO; class Program @@ -27,6 +30,17 @@ static void Main(string[] args) option.UseInMemory("m1"); + option.UseEtcd(options => + { + options.Address = "http://127.0.0.1:2379"; + options.Timeout = 30000; + options.SerializerName= "json"; + }, "e1").WithJson(jsonSerializerSettingsConfigure: x => + { + x.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.None; + x.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; + }, "json"); + option.UseRedis((options) => { options.SerializerName = "mempack"; @@ -43,17 +57,22 @@ static void Main(string[] args) }; }, "s1"); - // option.WithJson(jsonSerializerSettingsConfigure: x => - // { - // x.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.None; - // }, "json"); + option.WithJson(jsonSerializerSettingsConfigure: x => + { + x.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.None; + x.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; + }, "json"); option.UseDisk(cfg => { cfg.DBConfig = new DiskDbOptions { BasePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Cache") }; cfg.SerializerName = "msgpack"; }, "disk") - .WithJson("json") + .WithJson(jsonSerializerSettingsConfigure: x => + { + x.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.None; + x.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; + }, "json") .WithSystemTextJson("sysjson") .WithMessagePack("msgpack"); }); @@ -61,15 +80,15 @@ static void Main(string[] args) IServiceProvider serviceProvider = services.BuildServiceProvider(); var factory = serviceProvider.GetService(); - // var redisCache = factory.GetCachingProvider("r1"); - // - // redisCache.Set("rkey", new Product() { Name = "test" }, TimeSpan.FromSeconds(20)); - // - // var redisAllKey = redisCache.GetAllKeysByPrefix("rkey"); - // - // var redisVal = redisCache.Get("rkey"); - // - // Console.WriteLine($"redis cache get value, {redisVal.HasValue} {redisVal.IsNull} {redisVal.Value}"); + var redisCache = factory.GetCachingProvider("r1"); + + redisCache.Set("rkey", new Product() { Name = "test" }, TimeSpan.FromSeconds(20)); + + var redisAllKey = redisCache.GetAllKeysByPrefix("rkey"); + + var redisVal = redisCache.Get("rkey"); + + Console.WriteLine($"redis cache get value, {redisVal.HasValue} {redisVal.IsNull} {redisVal.Value}"); var prod = new Product() { @@ -104,6 +123,19 @@ static void Main(string[] args) var diskVal = diskCache.Get("diskkey"); Console.WriteLine($"disk cache get value, {diskVal.HasValue} {diskVal.IsNull} {diskVal.Value} "); + //etcd cache + var etcdCache = factory.GetCachingProvider("e1"); + var re11 = etcdCache.GetAllKeysByPrefix("emk"); + var re12 = etcdCache.GetByPrefix("emk"); + etcdCache.Set("emkey3", prod, TimeSpan.FromSeconds(2000)); + var re13 = etcdCache.Get("emkey3"); + var re14 = etcdCache.GetAll(new List() + { + "emkey3" + }); + etcdCache.Remove("emkey3"); + Console.WriteLine($"etcd cache get value, {re13.HasValue} {re13.IsNull} {re13.Value} "); + Console.ReadKey(); } } diff --git a/sample/EasyCaching.Demo.Providers/Controllers/ValuesController.cs b/sample/EasyCaching.Demo.Providers/Controllers/ValuesController.cs index d7f8878a..dc4f24d7 100644 --- a/sample/EasyCaching.Demo.Providers/Controllers/ValuesController.cs +++ b/sample/EasyCaching.Demo.Providers/Controllers/ValuesController.cs @@ -8,7 +8,7 @@ [Route("api/[controller]")] public class ValuesController : Controller { - //1. InMemory,Memcached,Redis,SQLite,FasterKv + //1. InMemory,Memcached,Redis,SQLite,FasterKv,Etcd private readonly IEasyCachingProvider _provider; public ValuesController(IEasyCachingProvider provider) diff --git a/sample/EasyCaching.Demo.Providers/EasyCaching.Demo.Providers.csproj b/sample/EasyCaching.Demo.Providers/EasyCaching.Demo.Providers.csproj index 116c4206..be344116 100644 --- a/sample/EasyCaching.Demo.Providers/EasyCaching.Demo.Providers.csproj +++ b/sample/EasyCaching.Demo.Providers/EasyCaching.Demo.Providers.csproj @@ -7,6 +7,8 @@ + + diff --git a/sample/EasyCaching.Demo.Providers/Startup.cs b/sample/EasyCaching.Demo.Providers/Startup.cs index 5372e2ae..2fe48365 100644 --- a/sample/EasyCaching.Demo.Providers/Startup.cs +++ b/sample/EasyCaching.Demo.Providers/Startup.cs @@ -8,6 +8,7 @@ using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Logging; + using Microsoft.Extensions.Options; public class Startup { @@ -69,6 +70,16 @@ public void ConfigureServices(IServiceCollection services) config.SerializerName = "msg"; }) .WithMessagePack("msg"); + + //use Etcd + option.UseEtcd(config => + { + config.Address = "http://127.0.0.1:2379"; + config.Timeout = 30000; + // Etcd must be set SerializerName + config.SerializerName = "json"; + }) + .WithMessagePack("msg2").WithJson("json"); }); } diff --git a/src/EasyCaching.Core/Internal/CachingProviderType.cs b/src/EasyCaching.Core/Internal/CachingProviderType.cs index ed1d8f27..d328e4a5 100644 --- a/src/EasyCaching.Core/Internal/CachingProviderType.cs +++ b/src/EasyCaching.Core/Internal/CachingProviderType.cs @@ -14,5 +14,6 @@ public enum CachingProviderType Ext2, LiteDB, FasterKv, + Etcd } } diff --git a/src/EasyCaching.Core/Internal/EasyCachingConstValue.cs b/src/EasyCaching.Core/Internal/EasyCachingConstValue.cs index 342a0ae4..fc84be55 100644 --- a/src/EasyCaching.Core/Internal/EasyCachingConstValue.cs +++ b/src/EasyCaching.Core/Internal/EasyCachingConstValue.cs @@ -45,6 +45,11 @@ public class EasyCachingConstValue /// public const string HybridSection = "easycaching:hybrid"; + /// + /// The etcd section. + /// + public const string EtcdSection = "easycaching:etcd"; + /// /// The redis bus section. /// @@ -53,13 +58,13 @@ public class EasyCachingConstValue /// /// The rabbitMQ Bus section. /// - public const string RabbitMQBusSection = "easycaching:rabbitmqbus"; - + public const string RabbitMQBusSection = "easycaching:rabbitmqbus"; + /// /// The kafka bus section. /// - public const string KafkaBusSection = "easycaching:kafkabus"; - + public const string KafkaBusSection = "easycaching:kafkabus"; + /// /// The zookeeper bus section. /// @@ -110,6 +115,12 @@ public class EasyCachingConstValue /// The default name of the LiteDB. /// public const string DefaultLiteDBName = "DefaultLiteDB"; + + /// + /// The default name of the etcd. + /// + public const string DefaultEtcdName = "DefaultEtcd"; + /// /// The LiteDB Bus section. /// diff --git a/src/EasyCaching.Etcd/Configurations/EtcdCachingOptions.cs b/src/EasyCaching.Etcd/Configurations/EtcdCachingOptions.cs new file mode 100644 index 00000000..e84b8755 --- /dev/null +++ b/src/EasyCaching.Etcd/Configurations/EtcdCachingOptions.cs @@ -0,0 +1,31 @@ +using EasyCaching.Core.Configurations; + +namespace EasyCaching.Etcd +{ + /// + /// EasyCaching options extensions of Etcd. + /// + public class EtcdCachingOptions : BaseProviderOptions + { + /// + /// Etcd address + /// cluster:like "https://localhost:23790,https://localhost:23791,https://localhost:23792" + /// + public string Address { get; set; } + + /// + /// Etcd access UserName + /// + public string UserName { get; set; } + + /// + /// Etcd access Pwd + /// + public string Password { get; set; } + + /// + /// Etcd timeout with Milliseconds + /// + public long Timeout { get; set; } = 3000; + } +} \ No newline at end of file diff --git a/src/EasyCaching.Etcd/Configurations/EtcdCachingOptionsExtensions.cs b/src/EasyCaching.Etcd/Configurations/EtcdCachingOptionsExtensions.cs new file mode 100644 index 00000000..3a109aa3 --- /dev/null +++ b/src/EasyCaching.Etcd/Configurations/EtcdCachingOptionsExtensions.cs @@ -0,0 +1,65 @@ +using System; +using EasyCaching.Core; +using EasyCaching.Core.Configurations; +using EasyCaching.Etcd; +using Microsoft.Extensions.Configuration; +// ReSharper disable CheckNamespace + +namespace Microsoft.Extensions.DependencyInjection; + +public static class EtcdCachingOptionsExtensions +{ + /// + /// Uses the Etcd provider (specify the config via hard code). + /// + /// Options. + /// Configure provider settings. + /// The name of this provider instance. + public static EasyCachingOptions UseEtcd( + this EasyCachingOptions options, + Action configure, + string name = EasyCachingConstValue.DefaultEtcdName + ) + { + ArgumentCheck.NotNull(configure, nameof(configure)); + + options.RegisterExtension(new EtcdOptionsExtension(name, configure)); + return options; + } + + /// + /// Uses the Etcd provider (read config from configuration file). + /// + /// Options. + /// The configuration. + /// The name of this provider instance. + /// The section name in the configuration file. + public static EasyCachingOptions UseEtcd( + this EasyCachingOptions options, + IConfiguration configuration, + string name = EasyCachingConstValue.DefaultEtcdName, + string sectionName = EasyCachingConstValue.EtcdSection + ) + { + var dbConfig = configuration.GetSection(sectionName); + var EtcdOptions = new EtcdCachingOptions(); + dbConfig.Bind(EtcdOptions); + + void Configure(EtcdCachingOptions x) + { + x.EnableLogging = EtcdOptions.EnableLogging; + x.MaxRdSecond = EtcdOptions.MaxRdSecond; + x.LockMs = EtcdOptions.LockMs; + x.SleepMs = EtcdOptions.SleepMs; + x.SerializerName = EtcdOptions.SerializerName; + x.CacheNulls = EtcdOptions.CacheNulls; + x.Address = EtcdOptions.Address; + x.UserName = EtcdOptions.UserName; + x.Password = EtcdOptions.Password; + x.Timeout= EtcdOptions.Timeout; + } + + options.RegisterExtension(new EtcdOptionsExtension(name, Configure)); + return options; + } +} \ No newline at end of file diff --git a/src/EasyCaching.Etcd/Configurations/EtcdOptionsExtension.cs b/src/EasyCaching.Etcd/Configurations/EtcdOptionsExtension.cs new file mode 100644 index 00000000..7eb8adc5 --- /dev/null +++ b/src/EasyCaching.Etcd/Configurations/EtcdOptionsExtension.cs @@ -0,0 +1,70 @@ +using System; +using EasyCaching.Core; +using EasyCaching.Core.Configurations; +using EasyCaching.Core.Serialization; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.DependencyInjection.Extensions; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Options; + +namespace EasyCaching.Etcd +{ + /// + /// Etcd options extension. + /// + internal sealed class EtcdOptionsExtension : IEasyCachingOptionsExtension + { + /// + /// The name. + /// + private readonly string _name; + + /// + /// The configure. + /// + private readonly Action _configure; + + /// + /// Initializes a new instance of the class. + /// + /// Name. + /// Configure. + public EtcdOptionsExtension(string name, Action configure) + { + _name = name; + _configure = configure; + } + + /// + /// Adds the services. + /// + /// Services. + public void AddServices(IServiceCollection services) + { + services.AddOptions(); + + services.Configure(_name, _configure); + + services.TryAddSingleton(); + + services.AddSingleton(x => + { + var optionsMon = x.GetRequiredService>(); + var options = optionsMon.Get(_name); + var factory = x.GetService(); + var serializers = x.GetServices(); + return new EtcdCaching(_name, options,serializers,factory); + }); + + services.AddSingleton(x => + { + var mCache = x.GetServices(); + var optionsMon = x.GetRequiredService>(); + var options = optionsMon.Get(_name); + var factory = x.GetService(); + var serializers = x.GetServices(); + return new DefaultEtcdCachingProvider(_name,mCache, options, serializers, factory); + }); + } + } +} diff --git a/src/EasyCaching.Etcd/DefaultEtcdCachingProvider.Async.cs b/src/EasyCaching.Etcd/DefaultEtcdCachingProvider.Async.cs new file mode 100644 index 00000000..626ebba0 --- /dev/null +++ b/src/EasyCaching.Etcd/DefaultEtcdCachingProvider.Async.cs @@ -0,0 +1,398 @@ +namespace EasyCaching.Etcd +{ + using EasyCaching.Core; + using Microsoft.Extensions.Logging; + using System; + using System.Collections.Generic; + using System.Text; + using System.Threading; + using System.Threading.Tasks; + + /// + /// MemoryCaching provider. + /// + public partial class DefaultEtcdCachingProvider : EasyCachingAbstractProvider + { + /// + /// Gets the specified cacheKey, dataRetriever and expiration async. + /// + /// The async. + /// Cache key. + /// Data retriever. + /// Expiration. + /// CancellationToken + /// The 1st type parameter. + public override async Task> BaseGetAsync(string cacheKey, Func> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration)); + + var result = await _cache.GetAsync(cacheKey); + if (result.HasValue) + { + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}"); + + CacheStats.OnHit(); + + return result; + } + + CacheStats.OnMiss(); + + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Missed : cachekey = {cacheKey}"); + + if (!await _cache.SetAsync($"{cacheKey}_Lock", "1", TimeSpan.FromMilliseconds(_options.LockMs))) + { + //wait for some ms + await Task.Delay(_options.SleepMs, cancellationToken); + return await GetAsync(cacheKey, dataRetriever, expiration); + } + + try + { + var res = await dataRetriever(); + + if (res != null || _options.CacheNulls) + { + await SetAsync(cacheKey, res, expiration); + //remove mutex key + await _cache.DeleteAsync($"{cacheKey}_Lock"); + + return new CacheValue(res, true); + } + else + { + //remove mutex key + await _cache.DeleteAsync($"{cacheKey}_Lock"); + return CacheValue.NoValue; + } + } + catch + { + //remove mutex key + await _cache.DeleteAsync($"{cacheKey}_Lock"); + throw; + } + } + + /// + /// Gets the specified cacheKey async. + /// + /// The async. + /// Cache key. + /// CancellationToken + /// The 1st type parameter. + public override async Task> BaseGetAsync(string cacheKey, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + + var result = await _cache.GetAsync(cacheKey); + + if (result.HasValue) + { + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}"); + + CacheStats.OnHit(); + + return result; + } + else + { + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Missed : cachekey = {cacheKey}"); + + CacheStats.OnMiss(); + + return CacheValue.NoValue; + } + } + + /// + /// Gets the count. + /// + /// The count. + /// Prefix. + /// CancellationToken + public override async Task BaseGetCountAsync(string prefix = "", CancellationToken cancellationToken = default) + { + var dicData = await _cache.GetAllAsync(prefix); + return dicData != null ? dicData.Count : 0; + } + + /// + /// Gets the specified cacheKey async. + /// + /// The async. + /// Cache key. + /// Object Type. + /// CancellationToken + public override async Task BaseGetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + + var result = await _cache.GetAsync(cacheKey); + + if (result != null) + { + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}"); + + CacheStats.OnHit(); + + return result; + } + else + { + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Missed : cachekey = {cacheKey}"); + + CacheStats.OnMiss(); + + return null; + } + } + + /// + /// Removes the specified cacheKey async. + /// + /// The async. + /// Cache key. + /// CancellationToken + public override async Task BaseRemoveAsync(string cacheKey, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + + await _cache.DeleteAsync(cacheKey); + } + + /// + /// Sets the specified cacheKey, cacheValue and expiration async. + /// + /// The async. + /// Cache key. + /// Cache value. + /// Expiration. + /// CancellationToken + /// The 1st type parameter. + public override async Task BaseSetAsync(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls); + ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration)); + + if (MaxRdSecond > 0) + { + var addSec = new Random().Next(1, MaxRdSecond); + expiration = expiration.Add(TimeSpan.FromMilliseconds(addSec)); + } + + //var valExpiration = expiration.Seconds <= 1 ? expiration : TimeSpan.FromSeconds(expiration.Seconds / 2); + //var val = new CacheValue(cacheValue, true, valExpiration); + await _cache.SetAsync(cacheKey, cacheValue, expiration); + } + + /// + /// Existses the specified cacheKey async. + /// + /// The async. + /// Cache key. + /// CancellationToken + public override async Task BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + + return await _cache.ExistsAsync(cacheKey); + } + + /// + /// Removes cached item by cachekey's prefix async. + /// + /// The by prefix async. + /// Prefix. + /// CancellationToken + public override async Task BaseRemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix)); + + var count = await _cache.DeleteRangeDataAsync(prefix); + + if (_options.EnableLogging) + _logger?.LogInformation($"RemoveByPrefixAsync : prefix = {prefix} , count = {count}"); + } + + /// + /// Removes cached items by pattern async. + /// + /// The by prefix async. + /// Pattern. + /// CancellationToken + public override async Task BaseRemoveByPatternAsync(string pattern, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullOrWhiteSpace(pattern, nameof(pattern)); + + throw new NotSupportedException("BaseRemoveByPatternAsync is not supported in Etcd provider."); + } + + /// + /// Sets all async. + /// + /// The all async. + /// Values. + /// Expiration. + /// CancellationToken + /// The 1st type parameter. + public override async Task BaseSetAllAsync(IDictionary values, TimeSpan expiration, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration)); + ArgumentCheck.NotNullAndCountGTZero(values, nameof(values)); + + foreach (var item in values) + { + await _cache.SetAsync(item.Key, item.Value, expiration); + } + } + + /// + /// Gets all async. + /// + /// The all async. + /// Cache keys. + /// CancellationToken + /// The 1st type parameter. + public override async Task>> BaseGetAllAsync(IEnumerable cacheKeys, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys)); + + if (_options.EnableLogging) + _logger?.LogInformation($"GetAllAsync : cacheKeys = {string.Join(",", cacheKeys)}"); + + Dictionary> result = new Dictionary>(); + foreach (var item in cacheKeys) + { + var value = await BaseGetAsync(item); + result.Add(item, value); + } + return result; + } + + /// + /// Get all cacheKey by prefix async. + /// + /// Cache keys. + /// Cache keys. + /// Get all cacheKey by prefix async. + public override async Task> BaseGetAllKeysByPrefixAsync(string prefix, CancellationToken cancellationToken = default) + { + if (_options.EnableLogging) + _logger?.LogInformation("GetAllKeysAsync"); + + var dicData = await _cache.GetAllAsync(prefix); + List result = new List(); + foreach (var item in dicData) + { + result.Add(item.Key); + } + return result; + } + + /// + /// Gets the by prefix async. + /// + /// The by prefix async. + /// Prefix. + /// CancellationToken + /// The 1st type parameter. + public override async Task>> BaseGetByPrefixAsync(string prefix, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix)); + + if (_options.EnableLogging) + _logger?.LogInformation($"GetByPrefixAsync : prefix = {prefix}"); + + var dicData = await _cache.GetAllAsync(prefix); + Dictionary> result = new Dictionary>(); + foreach (var item in dicData) + { + result.Add(item.Key, new CacheValue(_serializer.Deserialize(Encoding.UTF8.GetBytes(item.Value)), true)); + } + return result; + } + + /// + /// Removes all async. + /// + /// The all async. + /// Cache keys. + /// CancellationToken + public override async Task BaseRemoveAllAsync(IEnumerable cacheKeys, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys)); + + if (_options.EnableLogging) + _logger?.LogInformation($"RemoveAllAsync : cacheKeys = {string.Join(",", cacheKeys)}"); + + foreach (var item in cacheKeys) + { + await _cache.DeleteAsync(item); + } + } + + /// + /// Flush All Cached Item async. + /// + /// The async. + /// CancellationToken + public override async Task BaseFlushAsync(CancellationToken cancellationToken = default) + { + if (_options.EnableLogging) + _logger?.LogInformation("FlushAsync"); + + var dicData = await _cache.GetAllAsync(""); + if (dicData != null) + { + List listKeys = new List(dicData.Count); + foreach (var item in dicData) + { + listKeys.Add(item.Key); + } + await BaseRemoveAllAsync(listKeys); + } + //throw new NotSupportedException("BaseFlushAsync is not supported in Etcd provider."); + } + + /// + /// Tries the set async. + /// + /// The set async. + /// Cache key. + /// Cache value. + /// Expiration. + /// CancellationToken + /// The 1st type parameter. + public override async Task BaseTrySetAsync(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls); + ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration)); + + //var val = new CacheValue(cacheValue, true, expiration); + return await _cache.SetAsync(cacheKey, cacheValue, expiration); + } + + /// + /// Get the expiration of cache key + /// + /// cache key + /// CancellationToken + /// expiration + public override Task BaseGetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + + throw new NotSupportedException("BaseGetExpirationAsync is not supported in Etcd provider."); + } + } +} \ No newline at end of file diff --git a/src/EasyCaching.Etcd/DefaultEtcdCachingProvider.cs b/src/EasyCaching.Etcd/DefaultEtcdCachingProvider.cs new file mode 100644 index 00000000..79c814b4 --- /dev/null +++ b/src/EasyCaching.Etcd/DefaultEtcdCachingProvider.cs @@ -0,0 +1,431 @@ +using EasyCaching.Core; +using EasyCaching.Core.Serialization; +using Microsoft.Extensions.Logging; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace EasyCaching.Etcd +{ + public sealed partial class DefaultEtcdCachingProvider : EasyCachingAbstractProvider, IDisposable + { + // name + private readonly string _name; + + private bool _disposed; + + // com + private readonly ILogger? _logger; + + private readonly IEasyCachingSerializer _serializer; + private readonly EtcdCachingOptions _options; + + private readonly IEtcdCaching _cache; + + /// + /// The cache stats. + /// + private readonly CacheStats _cacheStats; + + private readonly ProviderInfo _info; + + public DefaultEtcdCachingProvider( + string name, + IEnumerable cache, + EtcdCachingOptions options, + IEnumerable serializers, + ILoggerFactory? loggerFactory = null) + { + ArgumentCheck.NotNull(options, nameof(options)); + ArgumentCheck.NotNull(serializers, nameof(serializers)); + + _name = name; + + _options = options; + _logger = loggerFactory?.CreateLogger(); + + _cache = cache.Single(x => x.ProviderName == _name); + + var serName = !string.IsNullOrWhiteSpace(options.SerializerName) ? options.SerializerName : name; + _serializer = serializers.FirstOrDefault(x => x.Name.Equals(serName)) ?? + throw new EasyCachingNotFoundException(string.Format( + EasyCachingConstValue.NotFoundSerExceptionMessage, + serName)); + + _cacheStats = new CacheStats(); + ProviderName = _name; + ProviderType = CachingProviderType.Etcd; + ProviderStats = _cacheStats; + ProviderMaxRdSecond = _options.MaxRdSecond; + IsDistributedProvider = false; + _info = new ProviderInfo + { + CacheStats = _cacheStats, + EnableLogging = options.EnableLogging, + IsDistributedProvider = IsDistributedProvider, + LockMs = options.LockMs, + MaxRdSecond = options.MaxRdSecond, + ProviderName = ProviderName, + ProviderType = ProviderType, + SerializerName = options.SerializerName, + SleepMs = options.SleepMs, + CacheNulls = options.CacheNulls + }; + } + + /// + /// Get the specified cacheKey, dataRetriever and expiration. + /// + /// The get. + /// Cache key. + /// Data retriever. + /// Expiration. + /// The 1st type parameter. + public override CacheValue BaseGet(string cacheKey, Func dataRetriever, TimeSpan expiration) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration)); + + var result = _cache.Get(cacheKey); + if (result.HasValue) + { + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}"); + + CacheStats.OnHit(); + + return result; + } + + CacheStats.OnMiss(); + + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Missed : cachekey = {cacheKey}"); + + if (!_cache.Set($"{cacheKey}_Lock", "1", TimeSpan.FromMilliseconds(_options.LockMs))) + { + System.Threading.Thread.Sleep(_options.SleepMs); + return Get(cacheKey, dataRetriever, expiration); + } + + try + { + var res = dataRetriever(); + + if (res != null || _options.CacheNulls) + { + Set(cacheKey, res, expiration); + //remove mutex key + _cache.Delete($"{cacheKey}_Lock"); + + return new CacheValue(res, true); + } + else + { + //remove mutex key + _cache.Delete($"{cacheKey}_Lock"); + return CacheValue.NoValue; + } + } + catch + { + //remove mutex key + _cache.Delete($"{cacheKey}_Lock"); + throw; + } + } + + /// + /// Get the specified cacheKey. + /// + /// The get. + /// Cache key. + /// The 1st type parameter. + public override CacheValue BaseGet(string cacheKey) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + + var result = _cache.Get(cacheKey); + if (result.HasValue) + { + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}"); + + CacheStats.OnHit(); + + return result; + } + else + { + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Missed : cachekey = {cacheKey}"); + + CacheStats.OnMiss(); + + return CacheValue.NoValue; + } + } + + /// + /// Remove the specified cacheKey. + /// + /// The remove. + /// Cache key. + public override void BaseRemove(string cacheKey) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + + _cache.Delete(cacheKey); + } + + /// + /// Set the specified cacheKey, cacheValue and expiration. + /// + /// The set. + /// Cache key. + /// Cache value. + /// expiration. + /// The 1st type parameter. + public override void BaseSet(string cacheKey, T cacheValue, TimeSpan expiration) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls); + ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration)); + + if (MaxRdSecond > 0) + { + var addSec = new Random().Next(1, MaxRdSecond); + expiration = expiration.Add(TimeSpan.FromMilliseconds(addSec)); + } + + //var valExpiration = expiration.Seconds <= 1 ? expiration : TimeSpan.FromSeconds(expiration.Seconds / 2); + //var val = new CacheValue(cacheValue, true, valExpiration); + _cache.Set(cacheKey, cacheValue, expiration); + } + + /// + /// Exists the specified cacheKey. + /// + /// The exists. + /// Cache key. + public override bool BaseExists(string cacheKey) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + + return _cache.Exists(cacheKey); + } + + /// + /// Removes cached item by cachekey's prefix. + /// + /// Prefix. + public override void BaseRemoveByPrefix(string prefix) + { + ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix)); + + var count = _cache.DeleteRangeData(prefix); + + if (_options.EnableLogging) + _logger?.LogInformation($"RemoveByPrefix : prefix = {prefix} , count = {count}"); + } + + /// + /// Removes cached items by pattern async. + /// + /// The by prefix async. + /// Pattern. + public override void BaseRemoveByPattern(string pattern) + { + ArgumentCheck.NotNullOrWhiteSpace(pattern, nameof(pattern)); + + throw new NotSupportedException("BaseRemoveByPattern is not supported in Etcd provider."); + } + + /// + /// Sets all. + /// + /// Values. + /// Expiration. + /// The 1st type parameter. + public override void BaseSetAll(IDictionary values, TimeSpan expiration) + { + ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration)); + ArgumentCheck.NotNullAndCountGTZero(values, nameof(values)); + + foreach (var item in values) + { + _cache.Set(item.Key, item.Value, expiration); + } + } + + /// + /// Gets all. + /// + /// The all. + /// Cache keys. + /// The 1st type parameter. + public override IDictionary> BaseGetAll(IEnumerable cacheKeys) + { + ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys)); + + if (_options.EnableLogging) + _logger?.LogInformation($"GetAll : cacheKeys = {string.Join(",", cacheKeys)}"); + + Dictionary> result = new Dictionary>(); + foreach (var item in cacheKeys) + { + var value = BaseGet(item); + result.Add(item, value); + } + return result; + } + + /// + /// Get all cacheKey by prefix. + /// + /// Prefix. + /// Get all cacheKey by prefix. + public override IEnumerable BaseGetAllKeysByPrefix(string prefix) + { + if (_options.EnableLogging) + _logger?.LogInformation("GetAllKeys"); + + var dicData = _cache.GetAll(prefix); + List result = new List(); + foreach (var item in dicData) + { + result.Add(item.Key); + } + return result; + } + + /// + /// Gets the by prefix. + /// + /// The by prefix. + /// Prefix. + /// The 1st type parameter. + public override IDictionary> BaseGetByPrefix(string prefix) + { + ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix)); + + if (_options.EnableLogging) + _logger?.LogInformation($"GetByPrefix : prefix = {prefix}"); + + var dicData = _cache.GetAll(prefix); + Dictionary> result = new Dictionary>(); + foreach (var item in dicData) + { + result.Add(item.Key, new CacheValue(_serializer.Deserialize(Encoding.UTF8.GetBytes(item.Value)), true)); + } + return result; + } + + /// + /// Removes all. + /// + /// Cache keys. + public override void BaseRemoveAll(IEnumerable cacheKeys) + { + ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys)); + + if (_options.EnableLogging) + _logger?.LogInformation($"RemoveAll : cacheKeys = {string.Join(",", cacheKeys)}"); + + foreach (var item in cacheKeys) + { + _cache.Delete(item); + } + } + + /// + /// Gets the count. + /// + /// The count. + /// Prefix. + public override int BaseGetCount(string prefix = "") + { + var dicData = _cache.GetAll(prefix); + return dicData != null ? dicData.Count : 0; + } + + /// + /// Flush All Cached Item. + /// + public override void BaseFlush() + { + if (_options.EnableLogging) + _logger?.LogInformation("Flush"); + + var dicData = _cache.GetAll(""); + if (dicData != null) + { + List listKeys = new List(dicData.Count); + foreach (var item in dicData) + { + listKeys.Add(item.Key); + } + if(listKeys.Count > 0) + BaseRemoveAll(listKeys); + } + // throw new NotSupportedException("BaseFlush is not supported in Etcd provider."); + } + + /// + /// Tries the set. + /// + /// true, if set was tryed, false otherwise. + /// Cache key. + /// Cache value. + /// Expiration. + /// The 1st type parameter. + public override bool BaseTrySet(string cacheKey, T cacheValue, TimeSpan expiration) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls); + ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration)); + + //var val = new CacheValue(cacheValue, true, expiration); + return _cache.Set(cacheKey, cacheValue, expiration); + } + + /// + /// Get the expiration of cache key + /// + /// cache key + /// expiration + public override TimeSpan BaseGetExpiration(string cacheKey) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + //_cache.LeaseTimeToLive(new LeaseTimeToLiveRequest() + //{ + // Keys + //}) + //return _cache.GetExpiration(cacheKey); + throw new NotSupportedException("BaseGetExpiration is not supported in Etcd provider."); + } + + /// + /// Get te information of this provider. + /// + /// + public override ProviderInfo BaseGetProviderInfo() => _info; + + public override object BaseGetDatabase() => _cache; + + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + private void Dispose(bool _) + { + if (_disposed) + return; + + _disposed = true; + } + } +} \ No newline at end of file diff --git a/src/EasyCaching.Etcd/EasyCaching.Etcd.csproj b/src/EasyCaching.Etcd/EasyCaching.Etcd.csproj new file mode 100644 index 00000000..08852122 --- /dev/null +++ b/src/EasyCaching.Etcd/EasyCaching.Etcd.csproj @@ -0,0 +1,53 @@ + + + + + + netstandard2.0;net6.0 + ncc;Catcher Wong + ncc;Catcher Wong + 10 + enable + true + $(EasyCachingEtcdPackageVersion) + + + A simple local caching provider based on ETCD. + + ETCD,File,LocalCache,Caching,Cache + https://github.com/dotnetcore/EasyCaching + LICENSE + https://github.com/dotnetcore/EasyCaching + https://github.com/dotnetcore/EasyCaching + nuget-icon.png + + $(EasyCachingEtcdPackageNotes) + + + + + + + + + + + + + + + + + + + + <_Parameter1>false + + + + + + + + + diff --git a/src/EasyCaching.Etcd/Internal/EtcdCaching.cs b/src/EasyCaching.Etcd/Internal/EtcdCaching.cs new file mode 100644 index 00000000..ba4141bf --- /dev/null +++ b/src/EasyCaching.Etcd/Internal/EtcdCaching.cs @@ -0,0 +1,275 @@ +using dotnet_etcd; +using EasyCaching.Core; +using EasyCaching.Core.Serialization; +using Etcdserverpb; +using Google.Protobuf; +using Grpc.Core; +using Microsoft.Extensions.Logging; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace EasyCaching.Etcd +{ + public class EtcdCaching : IEtcdCaching + { + // com + private readonly ILogger? _logger; + + private readonly IEasyCachingSerializer _serializer; + private readonly EtcdCachingOptions _options; + private readonly string _name; + + private readonly EtcdClient _cache; + private readonly string _authToken; + private readonly Grpc.Core.Metadata _metadata; + + public EtcdCaching( + string name, + EtcdCachingOptions options, + IEnumerable serializers, + ILoggerFactory? loggerFactory = null) + { + ArgumentCheck.NotNull(options, nameof(options)); + ArgumentCheck.NotNull(serializers, nameof(serializers)); + + _name = name; + _options = options; + _logger = loggerFactory?.CreateLogger(); + + //init etcd client + this._cache = new EtcdClient(connectionString: options.Address, configureChannelOptions: (x) => + { + x.Credentials = ChannelCredentials.Insecure; + }); + //auth + if (!string.IsNullOrEmpty(options.UserName) && !string.IsNullOrEmpty(options.Password)) + { + var authRes = this._cache.Authenticate(new Etcdserverpb.AuthenticateRequest() + { + Name = options.UserName, + Password = options.Password, + }); + _authToken = authRes.Token; + _metadata = new Grpc.Core.Metadata() { new Grpc.Core.Metadata.Entry("token", _authToken) }; + } + + var serName = !string.IsNullOrWhiteSpace(options.SerializerName) ? options.SerializerName : name; + _serializer = serializers.FirstOrDefault(x => x.Name.Equals(serName)) ?? + throw new EasyCachingNotFoundException(string.Format( + EasyCachingConstValue.NotFoundSerExceptionMessage, + serName)); + } + + public string ProviderName => this._name; + + #region etcd method + + /// + /// get data + /// + /// + /// + public CacheValue Get(string cacheKey) + { + var data = _cache.GetVal(cacheKey, _metadata); + return string.IsNullOrWhiteSpace(data) + ? CacheValue.Null + : new CacheValue(_serializer.Deserialize(Encoding.UTF8.GetBytes(data)), true); + } + + /// + /// get data + /// + /// + /// + public async Task> GetAsync(string cacheKey) + { + var data = await _cache.GetValAsync(cacheKey, _metadata); + return string.IsNullOrWhiteSpace(data) + ? CacheValue.Null + : new CacheValue(_serializer.Deserialize(Encoding.UTF8.GetBytes(data)), true); + } + + /// + /// get rangevalues + /// + /// + /// + public IDictionary GetAll(string prefixKey) + { + return _cache.GetRangeVal(prefixKey, _metadata); + } + + /// + /// get rangevalues + /// + /// + /// + public async Task> GetAllAsync(string prefixKey) + { + return await _cache.GetRangeValAsync(prefixKey, _metadata); + } + + /// + /// data exists + /// + /// + /// + public bool Exists(string cacheKey) + { + var data = _cache.GetVal(cacheKey, _metadata); + return data == string.Empty ? false : true; + } + + /// + /// data exists + /// + /// + /// + public async Task ExistsAsync(string cacheKey) + { + var data = await _cache.GetValAsync(cacheKey, _metadata); + return data == string.Empty ? false : true; + } + + /// + /// get rent leaseId + /// + /// + /// + private long GetRentLeaseId(TimeSpan? ts) + { + // create rent id to bind + CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(_options.Timeout)); + var response = _cache.LeaseGrant(request: new LeaseGrantRequest() + { + TTL = (long)(ts.Value.TotalMilliseconds < 1000 ? 1: ts.Value.TotalMilliseconds / 1000), + }, cancellationToken: cts.Token); + return response.ID; + } + + /// + /// get rent leaseId + /// + /// + /// + private async Task GetRentLeaseIdAsync(TimeSpan? ts) + { + // create rent id to bind + CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(_options.Timeout)); + var response = await _cache.LeaseGrantAsync(request: new LeaseGrantRequest() + { + TTL = (long)(ts.Value.TotalMilliseconds < 1000 ? 1 : ts.Value.TotalMilliseconds / 1000), + }, cancellationToken: cts.Token); + return response.ID; + } + + /// + /// put ke-val with leaseId + /// + /// + /// + /// + /// + public bool Set(string key, T value, TimeSpan? ts) + { + try + { + long leaseId = ts.HasValue ? GetRentLeaseId(ts) : 0; + CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(_options.Timeout)); + PutRequest request = new PutRequest() + { + Key = ByteString.CopyFromUtf8(key), + Value = ByteString.CopyFrom(_serializer.Serialize(value)), + Lease = leaseId + }; + var response = _cache.Put(request: request, headers: _metadata, cancellationToken: cts.Token); + return true; + } + catch (Exception ex) + { + _logger.LogError(ex, "putEphemeral(key:{},value:{}) error.", key, value); + } + return false; + } + + /// + /// put ke-val with leaseId + /// + /// + /// + /// + /// + public async Task SetAsync(string key, T value, TimeSpan? ts) + { + try + { + long leaseId = ts.HasValue ? await GetRentLeaseIdAsync(ts) : 0; + CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(_options.Timeout)); + PutRequest request = new PutRequest() + { + Key = ByteString.CopyFromUtf8(key), + Value = ByteString.CopyFrom(_serializer.Serialize(value)), + Lease = leaseId + }; + var response = await _cache.PutAsync(request: request, headers: _metadata, cancellationToken: cts.Token); + return true; + } + catch (Exception ex) + { + _logger.LogError(ex,"putEphemeral(key:{},value:{}) error.",key,value); + } + return false; + } + + /// + /// delete key + /// + /// + /// + public long Delete(string key) + { + var response = _cache.Delete(key, _metadata); + return response.Deleted; + } + + /// + /// delete key + /// + /// + /// + public async Task DeleteAsync(string key) + { + var response = await _cache.DeleteAsync(key, _metadata); + return response.Deleted; + } + + /// + /// delete range key + /// + /// + /// + public long DeleteRangeData(string prefixKey) + { + var response = _cache.DeleteRange(prefixKey, _metadata); + return response.Deleted; + } + + /// + /// delete range key + /// + /// + /// + public async Task DeleteRangeDataAsync(string prefixKey) + { + var response = await _cache.DeleteRangeAsync(prefixKey, _metadata); + return response.Deleted; + } + + #endregion etcd method + } +} \ No newline at end of file diff --git a/src/EasyCaching.Etcd/Internal/IEtcdCaching.cs b/src/EasyCaching.Etcd/Internal/IEtcdCaching.cs new file mode 100644 index 00000000..724b9a29 --- /dev/null +++ b/src/EasyCaching.Etcd/Internal/IEtcdCaching.cs @@ -0,0 +1,100 @@ +using EasyCaching.Core; +using System; +using System.Collections.Generic; +using System.Threading.Tasks; + +namespace EasyCaching.Etcd +{ + public interface IEtcdCaching + { + string ProviderName { get; } + + /// + /// get data + /// + /// + /// + CacheValue Get(string cacheKey); + + /// + /// get data + /// + /// + /// + Task> GetAsync(string cacheKey); + + /// + /// get rangevalues + /// + /// + /// + IDictionary GetAll(string prefixKey); + + /// + /// get rangevalues + /// + /// + /// + Task> GetAllAsync(string prefixKey); + + /// + /// data exists + /// + /// + /// + bool Exists(string cacheKey); + + /// + /// data exists + /// + /// + /// + Task ExistsAsync(string cacheKey); + + /// + /// put ke-val with leaseId + /// + /// + /// + /// + /// + bool Set(string key, T value, TimeSpan? ts); + + /// + /// put ke-val with leaseId + /// + /// + /// + /// + /// + Task SetAsync(string key, T value, TimeSpan? ts); + + /// + /// delete key + /// + /// + /// + long Delete(string key); + + /// + /// delete key + /// + /// + /// + Task DeleteAsync(string key); + + /// + /// delete range key + /// + /// + /// + long DeleteRangeData(string prefixKey); + + /// + /// delete range key + /// + /// + /// + Task DeleteRangeDataAsync(string prefixKey); + } +} \ No newline at end of file diff --git a/test/EasyCaching.UnitTests/CachingTests/EtcdCachingProviderTest.cs b/test/EasyCaching.UnitTests/CachingTests/EtcdCachingProviderTest.cs new file mode 100644 index 00000000..26a2e630 --- /dev/null +++ b/test/EasyCaching.UnitTests/CachingTests/EtcdCachingProviderTest.cs @@ -0,0 +1,137 @@ +//using System; +//using System.Threading.Tasks; +//using EasyCaching.Core; +//using EasyCaching.Core.Configurations; +//using Microsoft.Extensions.DependencyInjection; +//using Newtonsoft.Json; +//using Xunit; +//using Xunit.Abstractions; + +//namespace EasyCaching.UnitTests.CachingTests +//{ +// public class EtcdCachingProviderTest : BaseCachingProviderTest +// { +// private readonly ITestOutputHelper _testOutputHelper; + +// public EtcdCachingProviderTest(ITestOutputHelper testOutputHelper) +// { +// _testOutputHelper = testOutputHelper; +// _defaultTs = TimeSpan.FromSeconds(30); +// } + +// protected override IEasyCachingProvider CreateCachingProvider(Action additionalSetup) +// { +// var services = new ServiceCollection(); +// services.AddEasyCaching(x => +// x.UseEtcd(options => +// { +// options.Address = "http://127.0.0.1:2379"; +// options.Timeout = 30000; +// options.SerializerName = "json"; +// additionalSetup(options); +// }, "e1").WithJson(jsonSerializerSettingsConfigure: x => +// { +// x.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.None; +// x.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; +// }, "json")); + +// IServiceProvider serviceProvider = services.BuildServiceProvider(); +// return serviceProvider.GetService(); +// } + +// protected override Task GetAsync_Parallel_Should_Succeed() +// { +// return Task.FromResult(1); +// } + +// protected override void Get_Parallel_Should_Succeed() +// { +// } + +// protected override Task GetAllByPrefix_Async_Should_Throw_ArgumentNullException_When_Prefix_IsNullOrWhiteSpace( +// string preifx) +// { +// return Task.CompletedTask; +// } + +// protected override void GetAllByPrefix_Should_Throw_ArgumentNullException_When_CacheKey_IsNullOrWhiteSpace( +// string prefix) +// { +// } + +// protected override Task Get_Count_Async_With_Prefix_Should_Succeed() +// { +// return Task.CompletedTask; +// } + +// protected override Task Get_Count_Async_Without_Prefix_Should_Succeed() +// { +// return Task.CompletedTask; +// } + +// protected override void Get_Count_With_Prefix_Should_Succeed() +// { +// } + +// protected override void Get_Count_Without_Prefix_Should_Succeed() +// { +// } + +// protected override void GetByPrefix_Should_Succeed() +// { +// } + +// protected override void GetByPrefix_With_Not_Existed_Prefix_Should_Return_Empty_Dict() +// { +// } + +// protected override Task GetByPrefixAsync_Should_Succeed() +// { +// return Task.CompletedTask; +// } + +// protected override Task GetByPrefixAsync_With_Not_Existed_Prefix_Should_Return_Empty_Dict() +// { +// return Task.CompletedTask; +// } + +// protected override Task GetExpiration_Async_Should_Succeed() +// { +// return Task.CompletedTask; +// } + +// protected override void GetExpiration_Should_Succeed() +// { +// } + +// protected override void RemoveByPattern_Should_Succeed() +// { +// } + +// protected override Task RemoveByPatternAsync_Should_Succeed() +// { +// return Task.CompletedTask; +// } + +// protected override Task RemoveByPrefix_Async_Should_Throw_ArgumentNullException_When_Prefix_IsNullOrWhiteSpace( +// string preifx) + +// { +// return Task.CompletedTask; +// } + +// protected override void RemoveByPrefix_Should_Succeed() +// { +// } + +// protected override void RemoveByPrefix_Should_Throw_ArgumentNullException_When_CacheKey_IsNullOrWhiteSpace( +// string prefix) +// { +// } + +// protected override Task RemoveByPrefixAsync_Should_Succeed() +// { +// return Task.CompletedTask; +// } +// } +//} diff --git a/test/EasyCaching.UnitTests/EasyCaching.UnitTests.csproj b/test/EasyCaching.UnitTests/EasyCaching.UnitTests.csproj index 4c5c5b3b..32941270 100644 --- a/test/EasyCaching.UnitTests/EasyCaching.UnitTests.csproj +++ b/test/EasyCaching.UnitTests/EasyCaching.UnitTests.csproj @@ -31,6 +31,7 @@ +