Resolve separate DBreeze CoinDb implementation (stratisproject#1036)

* Resolve separate DBreeze CoinDb implementation

* Add tables

* Changes based on feedback

Author: quantumagi

src/Stratis.Bitcoin.Features.Consensus.Tests/CoinViews/CoinviewTests.cs

@@ -42,7 +42,7 @@ public CoinviewTests()
             this.loggerFactory = new ExtendedLoggerFactory();
             this.nodeStats = new NodeStats(this.dateTimeProvider, NodeSettings.Default(this.network), new Mock<IVersionProvider>().Object);
 
-            this.coindb = new DBreezeCoindb(this.network, this.dataFolder, this.dateTimeProvider, this.loggerFactory, this.nodeStats, new DBreezeSerializer(this.network.Consensus.ConsensusFactory));
+            this.coindb = new Coindb<DBreezeDbWithCoinDbNames>(this.network, this.dataFolder, this.dateTimeProvider, this.nodeStats, new DBreezeSerializer(this.network.Consensus.ConsensusFactory));
             this.coindb.Initialize();
 
             this.chainIndexer = new ChainIndexer(this.network);

src/Stratis.Bitcoin.Features.Consensus/CoinViews/Coindb/Coindb.cs

@@ -213,7 +213,7 @@ public void SaveChanges(IList<UnspentOutput> unspentOutputs, HashHeightPair oldB
         {
             int insertedEntities = 0;
 
-            using (var batch = this.coinDb.GetWriteBatch())
+            using (var batch = this.coinDb.GetWriteBatch(coinsTable, rewindTable, blockTable))
             {
                 using (new StopwatchDisposable(o => this.performanceCounter.AddInsertTime(o)))
                 {
@@ -300,7 +300,7 @@ private HashHeightPair RewindInternal(int startHeight, HashHeightPair target)
         {
             HashHeightPair res = null;
 
-            using (var batch = this.coinDb.GetWriteBatch())
+            using (var batch = this.coinDb.GetWriteBatch(coinsTable, rewindTable, blockTable))
             {
                 for (int height = startHeight; height > (target?.Height ?? (startHeight - 1)) && height > (startHeight - MaxRewindBatchSize); height--)
                 {

src/Stratis.Bitcoin.Features.Consensus/CoinViews/Coindb/DBreezeCoindb.cs

@@ -84,7 +84,7 @@ public static void ConfigureCoinDatabaseImplementation(this IServiceCollection s
             switch (coindbType)
             {
                 case DbType.Dbreeze:
-                    services.AddSingleton<ICoindb, DBreezeCoindb>();
+                    services.AddSingleton<ICoindb, Coindb<DBreezeDbWithCoinDbNames>>();
                     break;
 
                 case DbType.Leveldb:

src/Stratis.Bitcoin.Features.Consensus/FullNodeBuilderConsensusExtension.cs

@@ -0,0 +1,232 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using DBreeze;
+using DBreeze.DataTypes;
+using DBreeze.Transactions;
+
+namespace Stratis.Bitcoin.Database
+{
+    public class BatchContext : IDisposable
+    {
+        public Transaction transaction { get; private set; }
+
+        private bool canDispose;
+
+        public BatchContext(Transaction transaction, bool canDispose)
+        {
+            this.transaction = transaction;
+            this.canDispose = canDispose;
+        }
+
+        public void Dispose()
+        {
+            if (this.canDispose)
+                this.transaction.Dispose();
+        }
+    }
+
+    /// <summary>A minimal DBreeze wrapper that makes it compliant with the <see cref="IDb"/> interface.</summary>
+    public class DBreezeDb : IDb
+    {
+        private Dictionary<int, Transaction> transactions = new Dictionary<int, Transaction>();
+
+        private string dbPath;
+
+        private DBreezeEngine db;
+
+        private Dictionary<byte, string> tableNames;
+
+        public DBreezeDb(Dictionary<byte, string> tableNames)
+        {
+            this.tableNames = tableNames;
+        }
+
+        public IDbIterator GetIterator(byte table)
+        {
+            return new DBreezeIterator(this, this.tableNames[table]);
+        }
+
+        public IDbIterator GetIterator()
+        {
+            return new DBreezeIterator(this, "default");
+        }
+
+        public string GetTableName(byte table)
+        {
+            return this.tableNames[table];
+        }
+
+        public void Open(string dbPath)
+        {
+            this.dbPath = dbPath;
+            this.db = new DBreezeEngine(dbPath);
+        }
+
+        public void Clear()
+        {
+            this.db.Dispose();
+            System.IO.Directory.Delete(this.dbPath, true);
+            this.db = new DBreezeEngine(this.dbPath);
+        }
+
+        public IDbBatch GetWriteBatch(params byte[] tables) => new DBreezeBatch(this, tables);
+
+        private (Transaction transaction, bool canDispose) GetTransaction()
+        {
+            int threadId = AppDomain.GetCurrentThreadId();
+
+            // DBreeze does not allow nested transactions on the same thread.
+            // Re-use any existing transaction.
+            if (this.transactions.TryGetValue(threadId, out Transaction currentTransaction))
+            {
+                var disposedField = currentTransaction.GetType().GetField("disposed", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
+                if (!(bool)disposedField.GetValue(currentTransaction))
+                    return (currentTransaction, false);
+                this.transactions.Remove(threadId);
+            }
+
+            var transaction = this.db.GetTransaction(eTransactionTablesLockTypes.EXCLUSIVE);
+
+            this.transactions[threadId] = transaction;
+
+            return (transaction, true);
+        }
+
+        public BatchContext GetBatchContext(params byte[] tables)
+        {
+            (Transaction transaction, bool canDispose) = this.GetTransaction();
+
+            if (tables.Length != 0)
+                transaction.SynchronizeTables(tables.Select(t => this.tableNames[t]).ToArray());
+
+            return new BatchContext(transaction, canDispose);
+        }
+
+        public byte[] Get(byte table, byte[] key)
+        {
+            using (BatchContext ctx = this.GetBatchContext())
+            {
+                return ctx.transaction.Select<byte[], byte[]>(this.tableNames[table], key)?.Value;
+            }
+        }
+
+        public byte[] Get(byte[] key)
+        {
+            using (BatchContext ctx = this.GetBatchContext())
+            {
+                return ctx.transaction.Select<byte[], byte[]>("default", key)?.Value;
+            }
+        }
+
+        public void Dispose()
+        {
+            this.db.Dispose();
+        }
+    }
+
+    /// <summary>A minimal LevelDb wrapper that makes it compliant with the <see cref="IDbBatch"/> interface.</summary>
+    public class DBreezeBatch : IDbBatch
+    {
+        private DBreezeDb db;
+        private BatchContext context;
+
+        public DBreezeBatch(DBreezeDb db, params byte[] tables) : base()
+        {
+            this.db = db;
+            this.context = db.GetBatchContext(tables);
+        }
+
+        // Methods when using tables.
+
+        public IDbBatch Put(byte table, byte[] key, byte[] value)
+        {
+            this.context.transaction.Insert(this.db.GetTableName(table), key, value);
+            return this;
+        }
+
+        public IDbBatch Delete(byte table, byte[] key)
+        {
+            this.context.transaction.RemoveKey(this.db.GetTableName(table), key);
+            return this;
+        }
+
+        // Table-less operations.
+
+        public IDbBatch Put(byte[] key, byte[] value)
+        {
+            this.context.transaction.Insert("default", key, value);
+            return this;
+        }
+
+        public IDbBatch Delete(byte[] key)
+        {
+            this.context.transaction.RemoveKey("default", key);
+            return this;
+        }
+
+        public void Write()
+        {
+            this.context.transaction.Commit();
+        }
+
+        public void Dispose()
+        {
+            this.context.Dispose();
+        }
+    }
+
+    /// <summary>A minimal LevelDb wrapper that makes it compliant with the <see cref="IDbIterator"/> interface.</summary>
+    public class DBreezeIterator : IDbIterator
+    {
+        private BatchContext context;
+        private string tableName;
+        private Row<byte[], byte[]> current;
+
+        internal DBreezeIterator(DBreezeDb db, string tableName)
+        {
+            this.context = db.GetBatchContext();
+            this.tableName = tableName;
+        }
+
+        public void Seek(byte[] key)
+        {
+            this.current = this.context.transaction.SelectForwardStartFrom<byte[], byte[]>(this.tableName, key, includeStartFromKey: true, AsReadVisibilityScope: true).FirstOrDefault();
+        }
+
+        public void SeekToLast()
+        {
+            this.current = this.context.transaction.SelectBackward<byte[], byte[]>(this.tableName, AsReadVisibilityScope: true).FirstOrDefault();
+        }
+
+        public void Next()
+        {
+            this.current = this.context.transaction.SelectForwardStartFrom<byte[], byte[]>(this.tableName, this.current.Key, includeStartFromKey: false, AsReadVisibilityScope: true).FirstOrDefault();
+        }
+
+        public void Prev()
+        {
+            this.current = this.context.transaction.SelectBackwardStartFrom<byte[], byte[]>(this.tableName, this.current.Key, includeStartFromKey: false, AsReadVisibilityScope: true).FirstOrDefault();
+        }
+
+        public bool IsValid()
+        {
+            return this.current?.Exists ?? false;
+        }
+
+        public byte[] Key()
+        {
+            return this.current.Key;
+        }
+
+        public byte[] Value()
+        {
+            return this.current.Value;
+        }
+
+        public void Dispose()
+        {
+            this.context.Dispose();
+        }
+    }
+}

src/Stratis.Bitcoin/Database/DBreezeDb.cs

@@ -51,7 +51,7 @@ public interface IDb : IDisposable
         /// <remarks>The <see cref="IDb.Get"/> method will not reflect these changes until they are committed. Use
         /// the <see cref="ReadWriteBatch"/> class if uncommitted changes need to be accessed.</remarks>
         /// <returns>See <see cref="IDbBatch"/>.</returns>
-        IDbBatch GetWriteBatch();
+        IDbBatch GetWriteBatch(params byte[] tables);
 
         /// <summary>
         /// Removes all tables and their contents.

src/Stratis.Bitcoin/Database/IDb.cs

@@ -33,7 +33,7 @@ public void Clear()
             this.db = new DB(new Options() { CreateIfMissing = true }, this.dbPath);
         }
 
-        public IDbBatch GetWriteBatch() => new LevelDbBatch(this.db);
+        public IDbBatch GetWriteBatch(params byte[] tables) => new LevelDbBatch(this.db);
 
         public byte[] Get(byte table, byte[] key)
         {

src/Stratis.Bitcoin/Database/LevelDb.cs

@@ -34,7 +34,7 @@ public void Clear()
             this.db = RocksDbSharp.RocksDb.Open(new DbOptions().SetCreateIfMissing(), this.dbPath);
         }
 
-        public IDbBatch GetWriteBatch() => new RocksDbBatch(this.db);
+        public IDbBatch GetWriteBatch(params byte[] tables) => new RocksDbBatch(this.db);
 
         public byte[] Get(byte table, byte[] key)
         {