[DB] Specialize CScopedDBTransaction for evo database

random-zebra · random-zebra · commit 65b8ddcdd4d3 · 2021-04-11T10:21:57.000+02:00
&gt;&gt;&gt; backports dash@5b4fe43c2577f3f39fd174c84a8c23c99646903d

This has the wanted side effect of proper locking of "cs" inside
CommitCurTransaction and RollbackCurTransaction, which was not easily
possible to implement in the generic version. This fixes some rare
crashes.
diff --git a/src/dbwrapper.h b/src/dbwrapper.h
@@ -498,49 +498,4 @@ class CDBTransaction {
     }
 };
 
-template<typename Parent, typename CommitTarget>
-class CScopedDBTransaction {
-public:
-    typedef CDBTransaction<Parent, CommitTarget> Transaction;
-
-private:
-    Transaction &dbTransaction;
-    std::function<void ()> commitHandler;
-    std::function<void ()> rollbackHandler;
-    bool didCommitOrRollback{};
-
-public:
-    explicit CScopedDBTransaction(Transaction &dbTx) : dbTransaction(dbTx) {}
-    ~CScopedDBTransaction() {
-        if (!didCommitOrRollback)
-            Rollback();
-    }
-    void Commit() {
-        assert(!didCommitOrRollback);
-        didCommitOrRollback = true;
-        dbTransaction.Commit();
-        if (commitHandler)
-            commitHandler();
-    }
-    void Rollback() {
-        assert(!didCommitOrRollback);
-        didCommitOrRollback = true;
-        dbTransaction.Clear();
-        if (rollbackHandler)
-            rollbackHandler();
-    }
-
-    static std::unique_ptr<CScopedDBTransaction<Parent, CommitTarget>> Begin(Transaction &dbTx) {
-        assert(dbTx.IsClean());
-        return std::make_unique<CScopedDBTransaction<Parent, CommitTarget>>(dbTx);
-    }
-
-    void SetCommitHandler(const std::function<void ()> &h) {
-        commitHandler = h;
-    }
-    void SetRollbackHandler(const std::function<void ()> &h) {
-        rollbackHandler = h;
-    }
-};
-
 #endif // BITCOIN_DBWRAPPER_H
diff --git a/src/evo/evodb.cpp b/src/evo/evodb.cpp
@@ -7,6 +7,31 @@
 
 std::unique_ptr<CEvoDB> evoDb;
 
+CEvoDBScopedCommitter::CEvoDBScopedCommitter(CEvoDB &_evoDB) :
+    evoDB(_evoDB)
+{
+}
+
+CEvoDBScopedCommitter::~CEvoDBScopedCommitter()
+{
+    if (!didCommitOrRollback)
+        Rollback();
+}
+
+void CEvoDBScopedCommitter::Commit()
+{
+    assert(!didCommitOrRollback);
+    didCommitOrRollback = true;
+    evoDB.CommitCurTransaction();
+}
+
+void CEvoDBScopedCommitter::Rollback()
+{
+    assert(!didCommitOrRollback);
+    didCommitOrRollback = true;
+    evoDB.RollbackCurTransaction();
+}
+
 CEvoDB::CEvoDB(size_t nCacheSize, bool fMemory, bool fWipe) :
         db(fMemory ? "" : (GetDataDir() / "evodb"), nCacheSize, fMemory, fWipe),
         rootBatch(),
@@ -15,6 +40,18 @@ CEvoDB::CEvoDB(size_t nCacheSize, bool fMemory, bool fWipe) :
 {
 }
 
+void CEvoDB::CommitCurTransaction()
+{
+    LOCK(cs);
+    curDBTransaction.Commit();
+}
+
+void CEvoDB::RollbackCurTransaction()
+{
+    LOCK(cs);
+    curDBTransaction.Clear();
+}
+
 bool CEvoDB::CommitRootTransaction()
 {
     assert(curDBTransaction.IsClean());
diff --git a/src/evo/evodb.h b/src/evo/evodb.h
@@ -12,6 +12,22 @@
 
 static const std::string EVODB_BEST_BLOCK = "b_b";
 
+class CEvoDB;
+
+class CEvoDBScopedCommitter
+{
+private:
+    CEvoDB& evoDB;
+    bool didCommitOrRollback{false};
+
+public:
+    explicit CEvoDBScopedCommitter(CEvoDB& _evoDB);
+    ~CEvoDBScopedCommitter();
+
+    void Commit();
+    void Rollback();
+};
+
 class CEvoDB
 {
 private:
@@ -20,7 +36,6 @@ class CEvoDB
 
     typedef CDBTransaction<CDBWrapper, CDBBatch> RootTransaction;
     typedef CDBTransaction<RootTransaction, RootTransaction> CurTransaction;
-    typedef CScopedDBTransaction<RootTransaction, RootTransaction> ScopedTransaction;
 
     CDBBatch rootBatch;
     RootTransaction rootDBTransaction;
@@ -29,11 +44,10 @@ class CEvoDB
 public:
     explicit CEvoDB(size_t nCacheSize, bool fMemory = false, bool fWipe = false);
 
-    std::unique_ptr<ScopedTransaction> BeginTransaction()
+    std::unique_ptr<CEvoDBScopedCommitter> BeginTransaction()
     {
         LOCK(cs);
-        auto t = ScopedTransaction::Begin(curDBTransaction);
-        return t;
+        return std::make_unique<CEvoDBScopedCommitter>(*this);
     }
 
     template<typename K, typename V>
@@ -73,6 +87,12 @@ class CEvoDB
 
     bool VerifyBestBlock(const uint256& hash);
     void WriteBestBlock(const uint256& hash);
+
+private:
+    // only CEvoDBScopedCommitter is allowed to invoke these
+    friend class CEvoDBScopedCommitter;
+    void CommitCurTransaction();
+    void RollbackCurTransaction();
 };
 
 extern std::unique_ptr<CEvoDB> evoDb;
