Merge pull request #2335 from planetarium/bugfix/table-cache

fix table caching
planetarium · Dec 4, 2023 · 3961dc8 · 3961dc8
2 parents 027e866 + 4a896a3
commit 3961dc8
Show file tree

Hide file tree

Showing 6 changed files with 125 additions and 7 deletions.
diff --git a/NineChronicles.Headless.Tests/GraphTypes/StateQueryTest.cs b/NineChronicles.Headless.Tests/GraphTypes/StateQueryTest.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Security.Cryptography;
@@ -15,6 +16,7 @@
 using Nekoyume.Model.Garages;
 using Nekoyume.Model.Item;
 using Nekoyume.Model.State;
+using Nekoyume.TableData;
 using NineChronicles.Headless.GraphTypes;
 using NineChronicles.Headless.GraphTypes.States;
 using NineChronicles.Headless.Tests.Common;
@@ -222,6 +224,38 @@ public async Task Garage(
             }
         }
 
+        [Theory]
+        [InlineData(true, "expected")]
+        [InlineData(false, null)]
+        public async Task CachedSheet(bool cached, string? expected)
+        {
+            var tableName = nameof(ItemRequirementSheet);
+            var cache = new StateMemoryCache();
+            var cacheKey = Addresses.GetSheetAddress(tableName).ToString();
+            if (cached)
+            {
+                cache.SheetCache.SetSheet(cacheKey, (Text)expected, TimeSpan.FromMinutes(1));
+            }
+            var query = $"{{ cachedSheet(tableName: \"{tableName}\") }}";
+            MockState mockState = MockState.Empty;
+            var queryResult = await ExecuteQueryAsync<StateQuery>(
+                query,
+                source: new StateContext(
+                    mockState,
+                    0L, cache));
+            Assert.Null(queryResult.Errors);
+            var data = (Dictionary<string, object>)((ExecutionNode)queryResult.Data!).ToValue()!;
+            Assert.Equal(cached, cache.SheetCache.TryGetValue(cacheKey, out _));
+            if (cached)
+            {
+                Assert.Equal(expected, data["cachedSheet"]);
+            }
+            else
+            {
+                Assert.Null(data["cachedSheet"]);
+            }
+        }
+
         private static IEnumerable<object[]> GetMemberDataOfGarages()
         {
             var agentAddr = new PrivateKey().Address;

diff --git a/NineChronicles.Headless.Tests/MemoryCacheExtensionsTest.cs b/NineChronicles.Headless.Tests/MemoryCacheExtensionsTest.cs
@@ -0,0 +1,39 @@
+using System;
+using System.Threading.Tasks;
+using Bencodex;
+using Bencodex.Types;
+using MessagePack;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
+using Nekoyume;
+using Nekoyume.TableData;
+using Xunit;
+
+namespace NineChronicles.Headless.Tests;
+
+public class MemoryCacheExtensionsTest
+{
+    [Fact]
+    public async Task Sheet()
+    {
+        var codec = new Codec();
+        var lz4Options = MessagePackSerializerOptions.Standard.WithCompression(MessagePackCompression.Lz4BlockArray);
+        var cache = new MemoryCache(new OptionsWrapper<MemoryCacheOptions>(new MemoryCacheOptions
+        {
+            SizeLimit = null
+        }));
+
+        var sheets = TableSheetsImporter.ImportSheets();
+        var tableName = nameof(ItemRequirementSheet);
+        var csv = sheets[tableName];
+        var cacheKey = Addresses.GetSheetAddress(tableName).ToString();
+        var value = (Text)csv;
+        var compressed = MessagePackSerializer.Serialize(codec.Encode(value), lz4Options);
+        cache.SetSheet(cacheKey, value, TimeSpan.FromMilliseconds(100));
+        Assert.True(cache.TryGetValue(cacheKey, out byte[] cached));
+        Assert.Equal(compressed, cached);
+        Assert.Equal(csv, cache.GetSheet(cacheKey));
+        await Task.Delay(100);
+        Assert.False(cache.TryGetValue(cacheKey, out byte[] _));
+    }
+}
diff --git a/NineChronicles.Headless/ActionEvaluationPublisher.cs b/NineChronicles.Headless/ActionEvaluationPublisher.cs
@@ -118,7 +118,7 @@ public ActionEvaluationPublisher(
                 {
                     var action = ev.Action;
                     var sheetAddress = Addresses.GetSheetAddress(action.TableName);
-                    _memoryCache.Set(sheetAddress.ToString(), (Text)action.TableCsv);
+                    _memoryCache.SetSheet(sheetAddress.ToString(), (Text)action.TableCsv, TimeSpan.FromMinutes(1));
                 }
             });
         }

diff --git a/NineChronicles.Headless/BlockChainService.cs b/NineChronicles.Headless/BlockChainService.cs
@@ -44,7 +44,6 @@ public class BlockChainService : ServiceBase<IBlockChainService>, IBlockChainSer
         private ActionEvaluationPublisher _publisher;
         private ConcurrentDictionary<string, Sentry.ITransaction> _sentryTraces;
         private MemoryCache _memoryCache;
-        private readonly MessagePackSerializerOptions _lz4Options;
 
         public BlockChainService(
             BlockChain blockChain,
@@ -64,7 +63,6 @@ StateMemoryCache cache
             _publisher = actionEvaluationPublisher;
             _sentryTraces = sentryTraces;
             _memoryCache = cache.SheetCache;
-            _lz4Options = MessagePackSerializerOptions.Standard.WithCompression(MessagePackCompression.Lz4BlockArray);
         }
 
         public UnaryResult<bool> PutTransaction(byte[] txBytes)
@@ -245,9 +243,8 @@ public UnaryResult<Dictionary<byte[], byte[]>> GetSheets(
                 for (int i = 0; i < addresses.Count; i++)
                 {
                     var address = addresses[i];
-                    var value = _codec.Encode(values[i] ?? Null.Value);
-                    var compressed = MessagePackSerializer.Serialize(value, _lz4Options);
-                    _memoryCache.Set(address.ToString(), compressed);
+                    var value = values[i] ?? Null.Value;
+                    var compressed = _memoryCache.SetSheet(address.ToString(), value, TimeSpan.FromMinutes(1));
                     result.TryAdd(address.ToByteArray(), compressed);
                 }
             }

diff --git a/NineChronicles.Headless/GraphTypes/StateQuery.cs b/NineChronicles.Headless/GraphTypes/StateQuery.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Bencodex;
 using Bencodex.Types;
 using GraphQL;
 using GraphQL.Types;
@@ -11,7 +12,6 @@
 using Nekoyume;
 using Nekoyume.Action;
 using Nekoyume.Arena;
-using Nekoyume.Battle;
 using Nekoyume.Extensions;
 using Nekoyume.Model.Arena;
 using Nekoyume.Model.EnumType;
@@ -32,6 +32,8 @@ namespace NineChronicles.Headless.GraphTypes
 {
     public partial class StateQuery : ObjectGraphType<StateContext>
     {
+        private readonly Codec _codec = new Codec();
+
         public StateQuery()
         {
             Name = "StateQuery";
@@ -699,6 +701,22 @@ public StateQuery()
                     return result;
                 }
             );
+
+            Field<StringGraphType>(
+                name: "cachedSheet",
+                arguments: new QueryArguments(
+                    new QueryArgument<NonNullGraphType<StringGraphType>>
+                    {
+                        Name = "tableName"
+                    }
+                ),
+                resolve: context =>
+                {
+                    var tableName = context.GetArgument<string>("tableName");
+                    var cacheKey = Addresses.GetSheetAddress(tableName).ToString();
+                    return context.Source.StateMemoryCache.SheetCache.GetSheet(cacheKey);
+                }
+            );
         }
 
         public static List<RuneOptionSheet.Row.RuneOptionInfo> GetRuneOptions(

diff --git a/NineChronicles.Headless/MemoryCacheExtensions.cs b/NineChronicles.Headless/MemoryCacheExtensions.cs
@@ -0,0 +1,30 @@
+using System;
+using Bencodex;
+using Bencodex.Types;
+using MessagePack;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace NineChronicles.Headless;
+
+public static class MemoryCacheExtensions
+{
+    private static readonly Codec Codec = new Codec();
+    private static readonly MessagePackSerializerOptions Lz4Options = MessagePackSerializerOptions.Standard.WithCompression(MessagePackCompression.Lz4BlockArray);
+
+    public static byte[] SetSheet(this MemoryCache cache, string cacheKey, IValue value, TimeSpan ex)
+    {
+        var compressed = MessagePackSerializer.Serialize(Codec.Encode(value), Lz4Options);
+        cache.Set(cacheKey, compressed, ex);
+        return compressed;
+    }
+
+    public static string? GetSheet(this MemoryCache cache, string cacheKey)
+    {
+        if (cache.TryGetValue(cacheKey, out byte[] cached))
+        {
+            return (Text)Codec.Decode(MessagePackSerializer.Deserialize<byte[]>(cached, Lz4Options));
+        }
+
+        return null;
+    }
+}