Use TransactionManager to release transactions

Instead of events

Author: ilyalukyanov

src/LightningDB/Factories/CursorManager.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace LightningDB.Factories
+{
+    class CursorManager
+    {
+    }
+}

src/LightningDB/Factories/TransactionManager.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using LightningDB.Native;
+
+namespace LightningDB.Factories
+{
+    class TransactionManager
+    {
+        private readonly LightningEnvironment _environment;
+        private readonly LightningTransaction _parentTransaction;
+        private readonly IntPtr _parentHandle;
+
+        private readonly HashSet<LightningTransaction> _transactions;
+
+        public TransactionManager(LightningEnvironment environment, LightningTransaction parentTransaction)
+        {
+            if (environment == null)
+                throw new ArgumentNullException("environment");
+
+            _environment = environment;
+
+            _parentTransaction = parentTransaction;
+            _parentHandle = parentTransaction != null
+                ? parentTransaction._handle
+                : IntPtr.Zero;
+
+            _transactions = new HashSet<LightningTransaction>();
+        }
+
+        private void EnsureEnvironmentOpened()
+        {
+            if (!_environment.IsOpened)
+                throw new InvalidOperationException("Environment should be opened");
+        }
+
+        public LightningTransaction Create(TransactionBeginFlags beginFlags)
+        {
+            EnsureEnvironmentOpened();
+
+            IntPtr handle = default(IntPtr);
+            NativeMethods.Execute(lib => lib.mdb_txn_begin(_environment._handle, _parentHandle, beginFlags, out handle));
+
+            var tran = new LightningTransaction(_environment, handle, _parentTransaction, beginFlags);
+
+            _transactions.Add(tran);
+
+            return tran;
+        }
+
+        public void WasDiscarded(LightningTransaction tn)
+        {
+            _transactions.Remove(tn);
+        }
+
+        private static void AbortAll(TransactionManager manager)
+        {
+
+            foreach (var tn in manager._transactions.ToList())
+            {
+                AbortAll(tn.SubTransactionsManager);
+                tn.Abort();
+            }
+        }
+
+        public void AbortAll()
+        {
+            AbortAll(this);
+        }
+    }
+}

src/LightningDB/LightningCursor.cs

@@ -17,17 +17,14 @@ public class LightningCursor : IDisposable
         /// </summary>
         /// <param name="db">Database</param>
         /// <param name="txn">Transaction</param>
-        public LightningCursor(LightningDatabase db, LightningTransaction txn)
+        internal LightningCursor(LightningDatabase db, LightningTransaction txn)
         {
             if (db == null)
                 throw new ArgumentNullException("db");
 
             if (txn == null)
                 throw new ArgumentNullException("txn");
 
-            if (db.Environment != txn.Environment)
-                throw new ArgumentException("db and txn belong to different environments");
-
             IntPtr handle = default(IntPtr);
             NativeMethods.Execute(lib => lib.mdb_cursor_open(txn._handle, db._handle, out handle));
 
@@ -38,10 +35,11 @@ public LightningCursor(LightningDatabase db, LightningTransaction txn)
 
             _shouldDispose = true;
 
-            if (txn.IsReadOnly)
+            throw new NotImplementedException("Implement cursor manager");
+            /*if (txn.IsReadOnly)
                 this.Environment.Closing += EnvironmentOrTransactionClosing;
             else
-                this.Transaction.Closing += EnvironmentOrTransactionClosing;
+                this.Transaction.Closing += EnvironmentOrTransactionClosing;*/
         }
 
         private void EnvironmentOrTransactionClosing(object sender, EventArgs e)
@@ -55,10 +53,10 @@ private void EnvironmentOrTransactionClosing(object sender, EventArgs e)
 
         private void DetachClosingHandler()
         {
-            if (this.Transaction.IsReadOnly)
+            /*if (this.Transaction.IsReadOnly)
                 this.Environment.Closing -= EnvironmentOrTransactionClosing;
             else
-                this.Transaction.Closing -= EnvironmentOrTransactionClosing;
+                this.Transaction.Closing -= EnvironmentOrTransactionClosing;*/
         }
 
         /// <summary>

src/LightningDB/LightningDB.csproj

@@ -74,8 +74,10 @@
     <Compile Include="Collections\CursorEnumerator.cs" />
     <Compile Include="CursorGetByOperation.cs" />
     <Compile Include="CursorPutOptions.cs" />
+    <Compile Include="Factories\CursorManager.cs" />
     <Compile Include="Factories\DatabaseHandleCacheEntry.cs" />
     <Compile Include="Factories\DatabaseManager.cs" />
+    <Compile Include="Factories\TransactionManager.cs" />
     <Compile Include="GetByOperation.cs" />
     <Compile Include="LightningCursorExtensions.cs" />
     <Compile Include="LightningCursorMoveExtensions.cs">

src/LightningDB/LightningEnvironment.cs

@@ -24,6 +24,7 @@ public class LightningEnvironment : IClosingEventSource, IDisposable
         private int _maxDbs;
 
         private readonly DatabaseManager _databaseManager;
+        private readonly TransactionManager _transactionManager;
 
         /// <summary>
         /// Creates a new instance of LightningEnvironment.
@@ -58,6 +59,7 @@ public LightningEnvironment(string directory, EnvironmentOpenFlags openFlags = E
                 _maxDbs = LightningConfig.Environment.LibDefaultMaxDatabases;
 
             _databaseManager = new DatabaseManager(_handle);
+            _transactionManager = new TransactionManager(this, null);
 
             ConverterStore = new ConverterStore();
             var defaultConverters = new DefaultConverters();
@@ -160,6 +162,8 @@ public int MaxDatabases
 
         internal DatabaseManager DatabaseManager { get { return _databaseManager; } }
 
+        internal TransactionManager TransactionManager { get { return _transactionManager; } }
+
         /// <summary>
         /// Open the environment.
         /// </summary>
@@ -187,6 +191,7 @@ public void Close()
 
             this.OnClosing();
 
+            _transactionManager.AbortAll();
             _databaseManager.CloseAll();
 
             NativeMethods.Library.mdb_env_close(_handle);
@@ -225,9 +230,10 @@ protected virtual void OnClosing()
         /// </returns>
         public LightningTransaction BeginTransaction(LightningTransaction parent, TransactionBeginFlags beginFlags)
         {
-            this.EnsureOpened();
+            if (parent != null)
+                return parent.SubTransactionsManager.Create(beginFlags);
 
-            return new LightningTransaction(this, parent, beginFlags);
+            return _transactionManager.Create(beginFlags);
         }
 
         /// <summary>