Use CursorManager to release cursors

Instead of Closing event

Author: ilyalukyanov

src/LightningDB/Factories/CursorManager.cs

@@ -2,10 +2,65 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using LightningDB.Native;
 
 namespace LightningDB.Factories
 {
     class CursorManager
     {
+        private readonly LightningTransaction _transaction;
+
+        private readonly HashSet<IntPtr> _cursors;
+
+        public CursorManager(LightningTransaction transaction)
+        {
+            if (transaction == null)
+                throw new ArgumentNullException("transaction");
+
+            _transaction = transaction;
+
+            _cursors = new HashSet<IntPtr>();
+        }
+
+        private IntPtr CreateCursorHandle(uint dbHandle)
+        {
+            var handle = default(IntPtr);
+            NativeMethods.Execute(lib => lib.mdb_cursor_open(_transaction._handle, dbHandle, out handle));
+
+            return handle;
+        }
+
+        private void CloseCursor(IntPtr cursorHandle)
+        {
+            NativeMethods.Library.mdb_cursor_close(cursorHandle);
+        }
+
+        public LightningCursor OpenCursor(LightningDatabase db)
+        {
+            var handle = CreateCursorHandle(db._handle);
+            _cursors.Add(handle);
+
+            return new LightningCursor(db, _transaction, handle);
+        }
+
+        public void CloseCursor(LightningCursor cursor)
+        {
+            try
+            {
+                CloseCursor(cursor._handle);
+            }
+            finally
+            {
+                _cursors.Remove(cursor._handle);
+            }
+        }
+
+        public void CloseAll()
+        {
+            foreach (var handle in _cursors)
+                CloseCursor(handle);
+
+            _cursors.Clear();
+        }
     }
 }

src/LightningDB/IClosingEventSource.cs

@@ -9,54 +9,28 @@ namespace LightningDB
     /// </summary>
     public class LightningCursor : IDisposable
     {
-        private readonly IntPtr _handle;
+        internal readonly IntPtr _handle;
         private bool _shouldDispose;
 
         /// <summary>
         /// Creates new instance of LightningCursor
         /// </summary>
         /// <param name="db">Database</param>
         /// <param name="txn">Transaction</param>
-        internal LightningCursor(LightningDatabase db, LightningTransaction txn)
+        internal LightningCursor(LightningDatabase db, LightningTransaction txn, IntPtr handle)
         {
             if (db == null)
                 throw new ArgumentNullException("db");
 
             if (txn == null)
                 throw new ArgumentNullException("txn");
 
-            IntPtr handle = default(IntPtr);
-            NativeMethods.Execute(lib => lib.mdb_cursor_open(txn._handle, db._handle, out handle));
-
             _handle = handle;
 
             this.Database = db;
             this.Transaction = txn;
 
             _shouldDispose = true;
-
-            throw new NotImplementedException("Implement cursor manager");
-            /*if (txn.IsReadOnly)
-                this.Environment.Closing += EnvironmentOrTransactionClosing;
-            else
-                this.Transaction.Closing += EnvironmentOrTransactionClosing;*/
-        }
-
-        private void EnvironmentOrTransactionClosing(object sender, EventArgs e)
-        {
-            try
-            {
-                this.Close();
-            }
-            catch { }
-        }
-
-        private void DetachClosingHandler()
-        {
-            /*if (this.Transaction.IsReadOnly)
-                this.Environment.Closing -= EnvironmentOrTransactionClosing;
-            else
-                this.Transaction.Closing -= EnvironmentOrTransactionClosing;*/
         }
 
         /// <summary>
@@ -349,14 +323,7 @@ public void Renew(LightningTransaction txn)
         /// </summary>
         public void Close()
         {
-            try
-            {
-                NativeMethods.Library.mdb_cursor_close(_handle);
-            }
-            finally
-            {
-                this.DetachClosingHandler();
-            }
+            Transaction.CursorManager.CloseCursor(this);
         }
 
         /// <summary>

src/LightningDB/LightningCursor.cs

@@ -99,7 +99,6 @@
     <Compile Include="CursorDeleteOption.cs" />
     <Compile Include="CursorOperation.cs" />
     <Compile Include="DatabaseOpenFlags.cs" />
-    <Compile Include="IClosingEventSource.cs" />
     <Compile Include="LightningClosingEventArgs.cs" />
     <Compile Include="LightningCursor.cs" />
     <Compile Include="LightningDatabase.cs" />

src/LightningDB/LightningDB.csproj

@@ -11,7 +11,7 @@ namespace LightningDB
     /// <summary>
     /// LMDB Environment.
     /// </summary>
-    public class LightningEnvironment : IClosingEventSource, IDisposable
+    public class LightningEnvironment : IDisposable
     {
         private readonly UnixAccessMode _accessMode;
         private readonly EnvironmentOpenFlags _openFlags;
@@ -66,11 +66,6 @@ public LightningEnvironment(string directory, EnvironmentOpenFlags openFlags = E
             defaultConverters.RegisterDefault(this);
         }
 
-        /// <summary>
-        /// Triggered when the environment is going to close.
-        /// </summary>
-        public event EventHandler<LightningClosingEventArgs> Closing;
-
         /// <summary>
         /// Whether the environment is opened.
         /// </summary>
@@ -189,8 +184,6 @@ public void Close()
             if (!this.IsOpened)
                 return;
 
-            this.OnClosing();
-
             _transactionManager.AbortAll();
             _databaseManager.CloseAll();
 
@@ -201,15 +194,6 @@ public void Close()
             _shouldDispose = false;
         }
 
-        /// <summary>
-        /// Called when the environment is going to close.
-        /// </summary>
-        protected virtual void OnClosing()
-        {
-            if (this.Closing != null)
-                this.Closing(this, new LightningClosingEventArgs(true));
-        }
-
         /// <summary>
         /// Create a transaction for use with the environment.
         /// The transaction handle may be discarded using Abort() or Commit().

src/LightningDB/LightningEnvironment.cs

@@ -18,6 +18,7 @@ public class LightningTransaction : IDisposable
         internal IntPtr _handle;
 
         private readonly TransactionManager _subTransactionsManager;
+        private readonly CursorManager _cursorManager;
 
         /// <summary>
         /// Created new instance of LightningTransaction
@@ -37,10 +38,13 @@ internal LightningTransaction(LightningEnvironment environment, IntPtr handle, L
 
             _handle = handle;
             _subTransactionsManager = new TransactionManager(environment, this);
+            _cursorManager = new CursorManager(this);
         }
 
         internal TransactionManager SubTransactionsManager { get { return _subTransactionsManager; } }
 
+        internal CursorManager CursorManager { get { return _cursorManager; } }
+
         /// <summary>
         /// Current transaction state.
         /// </summary>
@@ -96,7 +100,7 @@ public void DropDatabase(LightningDatabase db, bool delete)
         /// <param name="db">A database.</param>
         public LightningCursor CreateCursor(LightningDatabase db)
         {
-            return new LightningCursor(db, this);
+            return CursorManager.OpenCursor(db);
         }
 
         private bool TryGetInternal(UInt32 dbi, byte[] key, out Func<byte[]> valueFactory)
@@ -259,18 +263,40 @@ private void NotifyDiscarded()
             manager.WasDiscarded(this);
         }
 
+        private void Discard(Action body)
+        {
+            try
+            {
+                _subTransactionsManager.AbortAll();
+            }
+            finally
+            {
+                try
+                {
+                    CursorManager.CloseAll();
+                }
+                finally
+                {
+                    try
+                    {
+                        body.Invoke();
+                    }
+                    finally
+                    {
+                        NotifyDiscarded();
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Commit all the operations of a transaction into the database.
         /// All cursors opened within the transaction will be closed by this call. 
         /// The cursors and transaction handle will be freed and must not be used again after this call.
         /// </summary>
         public void Commit()
         {
-            try
-            {
-                _subTransactionsManager.AbortAll();
-            }
-            finally
+            Discard(() =>
             {
                 try
                 {
@@ -285,7 +311,7 @@ public void Commit()
                     this.Abort();
                     throw;
                 }
-            }
+            });
         }
 
         /// <summary>
@@ -295,22 +321,11 @@ public void Commit()
         /// </summary>
         public void Abort()
         {
-            try
-            {
-                _subTransactionsManager.AbortAll();
-            }
-            finally
+            Discard(() =>
             {
-                try
-                {
-                    this.State = LightningTransactionState.Aborted;
-                    NativeMethods.Library.mdb_txn_abort(_handle);
-                }
-                finally
-                {
-                    NotifyDiscarded();
-                }
-            }
+                this.State = LightningTransactionState.Aborted;
+                NativeMethods.Library.mdb_txn_abort(_handle);
+            });
         }
 
         /// <summary>