Merge branch 'development' into PDX-203-config-json-schema

Libplanet.Extensions.PluggedActionEvaluator/Libplanet.Extensions.PluggedActionEvaluator.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Lib9c\.Libplanet\Libplanet\Libplanet.csproj" />
+    <ProjectReference Include="..\Lib9c\.Lib9c.Plugin.Shared\Lib9c.Plugin.Shared.csproj" />
+    <ProjectReference Include="..\Lib9c\.Libplanet.Extensions.ActionEvaluatorCommonComponents\Libplanet.Extensions.ActionEvaluatorCommonComponents.csproj" />
+  </ItemGroup>
+
+</Project>

Libplanet.Extensions.PluggedActionEvaluator/PluggedActionEvaluator.cs

@@ -0,0 +1,51 @@
+using System.Reflection;
+using System.Security.Cryptography;
+using Lib9c.Plugin.Shared;
+using Libplanet.Action;
+using Libplanet.Action.Loader;
+using Libplanet.Common;
+using Libplanet.Extensions.ActionEvaluatorCommonComponents;
+using Libplanet.Store.Trie;
+using Libplanet.Types.Blocks;
+
+namespace Libplanet.Extensions.PluggedActionEvaluator
+{
+    public class PluggedActionEvaluator : IActionEvaluator
+    {
+        private readonly IPluginActionEvaluator _pluginActionEvaluator;
+
+        public IActionLoader ActionLoader => throw new NotImplementedException();
+
+        public PluggedActionEvaluator(string pluginPath, string typeName, IKeyValueStore keyValueStore)
+        {
+            _pluginActionEvaluator = CreateActionEvaluator(pluginPath, typeName, keyValueStore);
+        }
+
+        public static Assembly LoadPlugin(string absolutePath)
+        {
+            PluginLoadContext loadContext = new PluginLoadContext(absolutePath);
+            return loadContext.LoadFromAssemblyName(new AssemblyName(Path.GetFileNameWithoutExtension(absolutePath)));
+        }
+
+        public static IPluginActionEvaluator CreateActionEvaluator(Assembly assembly, string typeName, IPluginKeyValueStore keyValueStore)
+        {
+            if (assembly.GetType(typeName) is Type type &&
+                Activator.CreateInstance(type, args: keyValueStore) as IPluginActionEvaluator
+                is IPluginActionEvaluator pluginActionEvaluator)
+            {
+                return pluginActionEvaluator;
+            }
+
+            throw new NullReferenceException("PluginActionEvaluator not found with given parameters");
+        }
+
+        public static IPluginActionEvaluator CreateActionEvaluator(string pluginPath, string typeName, IKeyValueStore keyValueStore)
+            => CreateActionEvaluator(LoadPlugin(pluginPath), typeName, new PluginKeyValueStore(keyValueStore));
+
+        public IReadOnlyList<ICommittedActionEvaluation> Evaluate(IPreEvaluationBlock block, HashDigest<SHA256>? baseStateRootHash)
+            => _pluginActionEvaluator.Evaluate(
+                PreEvaluationBlockMarshaller.Serialize(block),
+                baseStateRootHash is { } srh ? srh.ToByteArray() : null)
+                .Select(eval => ActionEvaluationMarshaller.Deserialize(eval)).ToList().AsReadOnly();
+    }
+}

Libplanet.Extensions.PluggedActionEvaluator/PluginKeyValueStore.cs

@@ -0,0 +1,42 @@
+using System.Collections.Immutable;
+using Lib9c.Plugin.Shared;
+using Libplanet.Store.Trie;
+
+namespace Libplanet.Extensions.PluggedActionEvaluator
+{
+    public class PluginKeyValueStore : IPluginKeyValueStore
+    {
+        private readonly IKeyValueStore _keyValueStore;
+
+        public PluginKeyValueStore(IKeyValueStore keyValueStore)
+        {
+            _keyValueStore = keyValueStore;
+        }
+        public byte[] Get(in ImmutableArray<byte> key) =>
+            _keyValueStore.Get(new KeyBytes(key));
+
+        public void Set(in ImmutableArray<byte> key, byte[] value) =>
+            _keyValueStore.Set(new KeyBytes(key), value);
+
+        public void Set(IDictionary<ImmutableArray<byte>, byte[]> values) =>
+            _keyValueStore.Set(
+                values.ToDictionary(kv =>
+                    new KeyBytes(kv.Key), kv => kv.Value));
+
+        public void Delete(in ImmutableArray<byte> key) =>
+            _keyValueStore.Delete(new KeyBytes(key));
+
+        public void Delete(IEnumerable<ImmutableArray<byte>> keys) =>
+            _keyValueStore.Delete(
+                keys.Select(key => new KeyBytes(key)));
+
+        public bool Exists(in ImmutableArray<byte> key) =>
+            _keyValueStore.Exists(new KeyBytes(key));
+
+        public IEnumerable<ImmutableArray<byte>> ListKeys() =>
+            _keyValueStore.ListKeys().Select(key => key.ByteArray);
+
+        public void Dispose() =>
+            _keyValueStore.Dispose();
+    }
+}

Libplanet.Extensions.PluggedActionEvaluator/PluginLoadContext.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.Loader;
+
+namespace Libplanet.Extensions.PluggedActionEvaluator
+{
+    public class PluginLoadContext : AssemblyLoadContext
+    {
+        private readonly AssemblyDependencyResolver _resolver;
+
+        public PluginLoadContext(string pluginPath)
+        {
+            _resolver = new AssemblyDependencyResolver(pluginPath);
+        }
+
+        protected override Assembly? Load(AssemblyName assemblyName)
+        {
+            if (_resolver.ResolveAssemblyToPath(assemblyName) is { } assemblyPath)
+            {
+                return LoadFromAssemblyPath(assemblyPath);
+            }
+
+            return null;
+        }
+
+        protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
+        {
+            if (_resolver.ResolveUnmanagedDllToPath(unmanagedDllName) is { } libraryPath)
+            {
+                return LoadUnmanagedDllFromPath(libraryPath);
+            }
+
+            return IntPtr.Zero;
+        }
+    }
+}
+

Libplanet.Headless/Hosting/ActionEvaluatorType.cs

@@ -4,5 +4,5 @@ public enum ActionEvaluatorType
 {
     Default,  // ActionEvaluator
     ForkableActionEvaluator,
-    RemoteActionEvaluator,
+    PluggedActionEvaluator,
 }

Libplanet.Headless/Hosting/LibplanetNodeService.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.IO;
+using System.IO.Compression;
 using System.Linq;
 using System.Net.Http;
 using System.Threading;
@@ -15,7 +16,7 @@
 using Libplanet.Types.Blocks;
 using Libplanet.Crypto;
 using Libplanet.Extensions.ForkableActionEvaluator;
-using Libplanet.Extensions.RemoteActionEvaluator;
+using Libplanet.Extensions.PluggedActionEvaluator;
 using Libplanet.Net;
 using Libplanet.Net.Consensus;
 using Libplanet.Net.Options;
@@ -80,8 +81,7 @@ public LibplanetNodeService(
             Action<bool> preloadStatusHandlerAction,
             IActionLoader actionLoader,
             bool ignoreBootstrapFailure = false,
-            bool ignorePreloadFailure = false,
-            bool useRemoteActionEvaluator = false
+            bool ignorePreloadFailure = false
         )
         {
             if (blockPolicy is null)
@@ -95,7 +95,7 @@ public LibplanetNodeService(
 
             var iceServers = Properties.IceServers;
 
-            (Store, StateStore) = LoadStore(
+            (Store, StateStore, IKeyValueStore keyValueStore) = LoadStore(
                 Properties.StorePath,
                 Properties.StoreType,
                 Properties.StoreStatesCacheSize);
@@ -116,23 +116,25 @@ public LibplanetNodeService(
             }
 
             var blockChainStates = new BlockChainStates(Store, StateStore);
+
             IActionEvaluator BuildActionEvaluator(IActionEvaluatorConfiguration actionEvaluatorConfiguration)
             {
                 return actionEvaluatorConfiguration switch
                 {
-                    RemoteActionEvaluatorConfiguration remoteActionEvaluatorConfiguration => new RemoteActionEvaluator(
-                        new Uri(remoteActionEvaluatorConfiguration.StateServiceEndpoint)),
-                    DefaultActionEvaluatorConfiguration _ => new ActionEvaluator(
-                        _ => blockPolicy.BlockAction,
-                        stateStore: StateStore,
-                        actionTypeLoader: actionLoader
-                    ),
-                    ForkableActionEvaluatorConfiguration forkableActionEvaluatorConfiguration => new
-                        ForkableActionEvaluator(
-                            forkableActionEvaluatorConfiguration.Pairs.Select(pair => (
-                                (pair.Item1.Start, pair.Item1.End), BuildActionEvaluator(pair.Item2)
-                            ))
-                        ),
+                    PluggedActionEvaluatorConfiguration pluginActionEvaluatorConfiguration =>
+                        new PluggedActionEvaluator(
+                            ResolvePluginPath(pluginActionEvaluatorConfiguration.PluginPath),
+                            pluginActionEvaluatorConfiguration.TypeName,
+                            keyValueStore),
+                    DefaultActionEvaluatorConfiguration _ =>
+                        new ActionEvaluator(
+                            _ => blockPolicy.BlockAction,
+                            stateStore: StateStore,
+                            actionTypeLoader: actionLoader),
+                    ForkableActionEvaluatorConfiguration forkableActionEvaluatorConfiguration =>
+                        new ForkableActionEvaluator(
+                            forkableActionEvaluatorConfiguration.Pairs.Select(
+                                pair => ((pair.Item1.Start, pair.Item1.End), BuildActionEvaluator(pair.Item2)))),
                     _ => throw new InvalidOperationException("Unexpected type."),
                 };
             }
@@ -302,7 +304,7 @@ public override async Task StopAsync(CancellationToken cancellationToken)
             }
         }
 
-        protected (IStore, IStateStore) LoadStore(string path, string type, int statesCacheSize)
+        protected (IStore, IStateStore, IKeyValueStore) LoadStore(string path, string type, int statesCacheSize)
         {
             IStore store = null;
             if (type == "rocksdb")
@@ -346,7 +348,7 @@ public override async Task StopAsync(CancellationToken cancellationToken)
 
             IKeyValueStore stateKeyValueStore = new RocksDBKeyValueStore(Path.Combine(path, "states"));
             IStateStore stateStore = new TrieStateStore(stateKeyValueStore);
-            return (store, stateStore);
+            return (store, stateStore, stateKeyValueStore);
         }
 
         private async Task StartSwarm(bool preload, CancellationToken cancellationToken)
@@ -568,7 +570,7 @@ protected async Task CheckPeerTable(CancellationToken cancellationToken = defaul
                     if (grace == count)
                     {
                         var message = "No any peers are connected even seed peers were given. " +
-                                     $"(grace: {grace}";
+                            $"(grace: {grace}";
                         Log.Error(message);
                         // _exceptionHandlerAction(RPCException.NetworkException, message);
                         Properties.NodeExceptionOccurred(NodeExceptionType.NoAnyPeer, message);
@@ -629,6 +631,32 @@ public override void Dispose()
             Log.Debug("Store disposed.");
         }
 
+        private string ResolvePluginPath(string path) =>
+            Uri.IsWellFormedUriString(path, UriKind.Absolute)
+                ? DownloadPlugin(path).Result
+                : path;
+
+        private async Task<string> DownloadPlugin(string url)
+        {
+            var path = Path.Combine(Environment.CurrentDirectory, "plugins");
+            Directory.CreateDirectory(path);
+            var hashed = url.GetHashCode().ToString();
+            var logger = Log.ForContext("LibplanetNodeService", hashed);
+            using var httpClient = new HttpClient();
+            var downloadPath = Path.Join(path, hashed + ".zip");
+            var extractPath = Path.Join(path, hashed);
+            logger.Debug("Downloading...");
+            await File.WriteAllBytesAsync(
+                downloadPath,
+                await httpClient.GetByteArrayAsync(url, SwarmCancellationToken),
+                SwarmCancellationToken);
+            logger.Debug("Finished downloading.");
+            logger.Debug("Extracting...");
+            ZipFile.ExtractToDirectory(downloadPath, extractPath);
+            logger.Debug("Finished extracting.");
+            return Path.Combine(extractPath, "Lib9c.Plugin.dll");
+        }
+
         // FIXME: Request libplanet provide default implementation.
         private sealed class ActionTypeLoaderContext : IActionTypeLoaderContext
         {

Libplanet.Headless/Hosting/PluggedActionEvaluatorConfiguration.cs

@@ -0,0 +1,10 @@
+namespace Libplanet.Headless.Hosting;
+
+public class PluggedActionEvaluatorConfiguration : IActionEvaluatorConfiguration
+{
+    public ActionEvaluatorType Type => ActionEvaluatorType.PluggedActionEvaluator;
+
+    public string PluginPath { get; init; }
+
+    public string TypeName => "Lib9c.Plugin.PluginActionEvaluator";
+}

Libplanet.Headless/Libplanet.Headless.csproj

@@ -23,7 +23,7 @@
     <ProjectReference Include="..\Lib9c\.Libplanet\Libplanet.RocksDBStore\Libplanet.RocksDBStore.csproj" />
     <ProjectReference Include="..\Lib9c\.Libplanet\Libplanet.Net\Libplanet.Net.csproj" />
     <ProjectReference Include="..\NineChronicles.RPC.Shared\NineChronicles.RPC.Shared\NineChronicles.RPC.Shared.csproj" />
-    <ProjectReference Include="..\Lib9c\.Libplanet.Extensions.RemoteActionEvaluator\Libplanet.Extensions.RemoteActionEvaluator.csproj" />
     <ProjectReference Include="..\Libplanet.Extensions.ForkableActionEvaluator\Libplanet.Extensions.ForkableActionEvaluator.csproj" />
+    <ProjectReference Include="..\Libplanet.Extensions.PluggedActionEvaluator\Libplanet.Extensions.PluggedActionEvaluator.csproj" />
   </ItemGroup>
 </Project>

NineChronicles.Headless.Executable.Tests/Commands/TxCommandTest.cs

@@ -131,11 +131,7 @@ private void Assert_Tx(long txNonce, string filePath, bool gas)
         {
             var timeStamp = DateTimeOffset.FromUnixTimeSeconds(DateTimeOffset.UtcNow.ToUnixTimeSeconds());
             var hashHex = ByteUtil.Hex(_blockHash.ByteArray);
-            long? maxGasPrice = null;
-            if (gas)
-            {
-                maxGasPrice = 1L;
-            }
+            long? maxGasPrice = gas ? (long?)1L : null;
             _command.Sign(ByteUtil.Hex(_privateKey.ByteArray), txNonce, hashHex, timeStamp.ToString(),
                 new[] { filePath }, maxGasPrice: maxGasPrice);
             var output = _console.Out.ToString();
@@ -146,11 +142,12 @@ private void Assert_Tx(long txNonce, string filePath, bool gas)
             Assert.Equal(_privateKey.Address, tx.Signer);
             Assert.Equal(timeStamp, tx.Timestamp);
             ActionBase action = (ActionBase)new NCActionLoader().LoadAction(1L, tx.Actions.Single());
-            long expectedGasLimit = 1L;
-            if (action is ITransferAsset || action is ITransferAssets)
-            {
-                expectedGasLimit = 4L;
-            }
+            long? expectedGasLimit = gas
+                ? action is ITransferAsset || action is ITransferAssets
+                    ? (long?)4L
+                    : (long?)1L
+                : null;
+
             Assert.Equal(expectedGasLimit, tx.GasLimit);
             if (gas)
             {