Feature block generation

AElf.Database/DatabaseConfig.cs

@@ -2,7 +2,7 @@
 {
     public class DatabaseConfig
     {
-        public string IpAddress { get; set; }
-        public int Port { get; set; }
+        public string IpAddress { get; set; } = "127.0.0.1";
+        public int Port { get; set; } = 6379;
     }
 }

AElf.Database/RedisDatabase.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices.ComTypes;
 using System.Text;
 using System.Threading.Tasks;
 using AElf.Database;
@@ -12,21 +13,23 @@ namespace AElf.Database
 {
     public class RedisDatabase : IKeyValueDatabase
     {
-        private readonly RedisClient _client;
+        private readonly IRedisClient _client;
 
-        public RedisDatabase()
+        public RedisDatabase():this(new DatabaseConfig())
         {
-            _client = new RedisClient("127.0.0.1", 6379);;
         }
 
         public RedisDatabase(DatabaseConfig config)
         {
-            _client = new RedisClient(config.IpAddress, config.Port);
+            using (var redisManager = new RedisManagerPool($"{config.IpAddress}:{config.Port}"))
+            {
+                _client = redisManager.GetClient();
+            }
         }
 
         public async Task<byte[]> GetAsync(string key, Type type)
         {
-            return await Task.FromResult(_client.Get(key));
+            return await Task.FromResult(_client.Get<byte[]>(key));
         }
 
         public async Task SetAsync(string key, byte[] bytes)
@@ -38,7 +41,7 @@ public bool IsConnected()
         {
             try
             {
-                _client.Set("test", null);
+                _client.Set<byte[]>("test", null);
                 return true;
             }
             catch (Exception ex)

AElf.Kernel.Modules.AutofacModule/DatabaseModule.cs

@@ -1,13 +1,26 @@
-using AElf.Database;
+using System;
+using AElf.Database;
 using Autofac;
+using ServiceStack.Redis;
 
 namespace AElf.Kernel.Modules.AutofacModule
 {
     public class DatabaseModule : Module
     {
+        private readonly bool _useRedis = false;
         protected override void Load(ContainerBuilder builder)
         {
-            builder.RegisterType<KeyValueDatabase>().As<IKeyValueDatabase>();
+            if (_useRedis)
+            {
+                if (!new RedisDatabase().IsConnected()) 
+                    return;
+
+                builder.RegisterType<RedisDatabase>().As<IKeyValueDatabase>();
+            }
+            else
+            {
+                builder.RegisterType<KeyValueDatabase>().As<IKeyValueDatabase>().SingleInstance();
+            }
         }
     }
 }

AElf.Kernel.Tests/BlockTest.cs

@@ -1,6 +1,8 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using AElf.Kernel.KernelAccount;
 using AElf.Kernel.Managers;
+using Google.Protobuf.Collections;
 using Xunit;
 using Xunit.Frameworks.Autofac;
 
@@ -34,19 +36,27 @@ public void GenesisBlockBuilderTest()
         [Fact]
         public async Task BlockManagerTest()
         {
-            var builder = new GenesisBlockBuilder().Build(_smartContractZero.GetType());
-            var genesisBlock = builder.Block;
-
-            await _blockManager.AddBlockAsync(genesisBlock);
-            var blockHeader = await _blockManager.GetBlockHeaderAsync(genesisBlock.GetHash());
-
-            var block = new Block(genesisBlock.GetHash());
-
             var chain = await _chainTest.CreateChainTest();
-            await _chainTest.AppendBlockTest(chain, block);
-            Assert.Equal(blockHeader, genesisBlock.Header);
+
+            var block = CreateBlock(chain.GenesisBlockHash);
+            await _blockManager.AddBlockAsync(block);
+            var b = await _blockManager.GetBlockAsync(block.GetHash());
+            Assert.Equal(b, block);
         }
 
+        private Block CreateBlock(Hash preBlockHash = null)
+        {
+            Interlocked.CompareExchange(ref preBlockHash, Hash.Zero, null);
+
+            var block = new Block(Hash.Generate());
+            block.AddTransaction(Hash.Generate());
+            block.AddTransaction(Hash.Generate());
+            block.AddTransaction(Hash.Generate());
+            block.AddTransaction(Hash.Generate());
+            block.FillTxsMerkleTreeRootInHeader();
+            block.Header.PreviousHash = preBlockHash;
+            return block;
+        }
 
     }
 }

AElf.Kernel.Tests/ChainTest.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using AElf.Kernel.KernelAccount;
 using AElf.Kernel.Managers;
 using AElf.Kernel.Services;
@@ -38,40 +39,63 @@ public async Task<IChain> CreateChainTest()
             var chainId = Hash.Generate();
             var chain = await _chainCreationService.CreateNewChainAsync(chainId, _smartContractZero.GetType());
 
-            await _chainManager.AppendBlockToChainAsync(chain, new Block(Hash.Generate()));
+            /*// add chain to storage
+            var genesisBlock = new Block(Hash.Zero);
+            await _chainManager.AddChainAsync(chain.Id, genesisBlock.GetHash());
+
+            var block = new Block(genesisBlock.GetHash()) {Header = {PreviousHash = genesisBlock.GetHash()}};
+            await _chainManager.AppendBlockToChainAsync(chain.Id, block);
 
             var address = Hash.Generate();
-            var accountContextService = new AccountContextService();
-            var worldStateManager = new WorldStateManager(_worldStateStore, 
-                accountContextService, _changesStore, _dataStore);
-            var accountDataProvider = worldStateManager.GetAccountDataProvider(chainId, address);
+            var worldStateManager = await new WorldStateManager(_worldStateStore, 
+                _changesStore, _dataStore).OfChain(chainId);
+            var accountDataProvider = worldStateManager.GetAccountDataProvider(address);
 
-            await _smartContractZero.InitializeAsync(accountDataProvider);
-            Assert.Equal(chain.CurrentBlockHeight, (ulong)1);
+            await _smartContractZero.InitializeAsync(accountDataProvider);*/
+            Assert.Equal(await _chainManager.GetChainCurrentHeight(chain.Id), (ulong)1);
             return chain;
         }
 
         public async Task ChainStoreTest(Hash chainId)
         {
-            await _chainManager.AddChainAsync(chainId);
+            await _chainManager.AddChainAsync(chainId, Hash.Generate());
             Assert.NotNull(_chainManager.GetChainAsync(chainId).Result);
         }
 
         public async Task ChainContextTest()
         {
             var chain = await CreateChainTest();
-            await _chainManager.AddChainAsync(chain.Id);
+            await _chainManager.AddChainAsync(chain.Id, Hash.Generate());
             chain = await _chainManager.GetChainAsync(chain.Id);
             var context = _chainContextService.GetChainContext(chain.Id);
             Assert.NotNull(context);
             Assert.Equal(context.SmartContractZero, _smartContractZero);
         }
 
-        public async Task AppendBlockTest(IChain chain, Block block)
+        [Fact]
+        public async Task AppendBlockTest()
         {
-            await _chainManager.AppendBlockToChainAsync(chain, block);
-            Assert.Equal(chain.CurrentBlockHeight, (ulong)2);
-            Assert.Equal(chain.CurrentBlockHash, block.GetHash());
+            var chain = await CreateChainTest();
+
+            var block = CreateBlock(chain.GenesisBlockHash);
+            await _chainManager.AppendBlockToChainAsync(chain.Id, block);
+            Assert.Equal(await _chainManager.GetChainCurrentHeight(chain.Id), (ulong)2);
+            Assert.Equal(await _chainManager.GetChainLastBlockHash(chain.Id), block.GetHash());
+            Assert.Equal(block.Header.Index, (ulong)1);
+        }
+
+        private Block CreateBlock(Hash preBlockHash = null)
+        {
+            Interlocked.CompareExchange(ref preBlockHash, Hash.Zero, null);
+
+            var block = new Block(Hash.Generate());
+            block.AddTransaction(Hash.Generate());
+            block.AddTransaction(Hash.Generate());
+            block.AddTransaction(Hash.Generate());
+            block.AddTransaction(Hash.Generate());
+            block.FillTxsMerkleTreeRootInHeader();
+            block.Header.PreviousHash = preBlockHash;
+            return block;
         }
     }
 }

AElf.Kernel.Tests/DataProviderTest.cs

@@ -1,12 +1,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using AElf.Database;
 using AElf.Kernel.Extensions;
 using AElf.Kernel.Managers;
-using AElf.Kernel.Services;
 using AElf.Kernel.Storages;
-using Google.Protobuf;
 using Xunit;
 using Xunit.Frameworks.Autofac;
 
@@ -34,17 +31,16 @@ public async Task SetTest()
             const int count = 5;
             var setList = CreateSet(count).ToList();
             var keys = GenerateKeys(setList).ToList();
-
-            var chain = new Chain(Hash.Generate());
-            var chainManager = new ChainManager(_chainStore);
-            await chainManager.AddChainAsync(chain.Id);
+
+            var genesisBlockHash = Hash.Generate();
+            var chain = new Chain(Hash.Generate(), genesisBlockHash);
+            var chainManager = new ChainManager(_chainStore, _dataStore);
+            await chainManager.AddChainAsync(chain.Id, genesisBlockHash);
 
             var address = Hash.Generate();
-            var accountContextService = new AccountContextService();
-            var worldStateManager = new WorldStateManager(_worldStateStore, accountContextService,
-                _changesStore, _dataStore);
-            await worldStateManager.SetWorldStateAsync(chain.Id, Hash.Generate());
-            var accountDataProvider = worldStateManager.GetAccountDataProvider(chain.Id, address);
+            var worldStateManager = await new WorldStateManager(_worldStateStore, _changesStore, _dataStore).OfChain(chain.Id);
+            await worldStateManager.SetWorldStateAsync(genesisBlockHash);
+            var accountDataProvider = worldStateManager.GetAccountDataProvider(address);
             var dataProvider = accountDataProvider.GetDataProvider();
 
             for (var i = 0; i < count; i++)