Add error handler

Synchronized fixed
QuantConnect · jaredbroad · Mar 28, 2019 · Jun 23, 2018 · Jun 24, 2018 · Jun 24, 2018
commit 3a9be30e31f1e343a1e6283fb85fd55a06a2d679
diff --git a/src/embed_tests/TestFinalizer.cs b/src/embed_tests/TestFinalizer.cs
@@ -151,5 +151,59 @@ public void SimpleTestMemory()
                 Finalizer.Instance.Enable = oldState;
             }
         }
+
+        class MyPyObject : PyObject
+        {
+            public MyPyObject(IntPtr op) : base(op)
+            {
+            }
+
+            protected override void Dispose(bool disposing)
+            {
+                base.Dispose(disposing);
+                GC.SuppressFinalize(this);
+                throw new Exception("MyPyObject");
+            }
+            internal static void CreateMyPyObject(IntPtr op)
+            {
+                Runtime.Runtime.XIncref(op);
+                new MyPyObject(op);
+            }
+        }
+
+        [Test]
+        public void ErrorHandling()
+        {
+            bool called = false;
+            EventHandler<Finalizer.ErrorArgs> handleFunc = (sender, args) =>
+            {
+                called = true;
+                Assert.AreEqual(args.Error.Message, "MyPyObject");
+            };
+            Finalizer.Instance.Threshold = 1;
+            Finalizer.Instance.ErrorHandler += handleFunc;
+            try
+            {
+                WeakReference shortWeak;
+                WeakReference longWeak;
+                {
+                    MakeAGarbage(out shortWeak, out longWeak);
+                    var obj = (PyLong)longWeak.Target;
+                    IntPtr handle = obj.Handle;
+                    shortWeak = null;
+                    longWeak = null;
+                    MyPyObject.CreateMyPyObject(handle);
+                    obj.Dispose();
+                    obj = null;
+                }
+                FullGCCollect();
+                Finalizer.Instance.Collect();
+                Assert.IsTrue(called);
+            }
+            finally
+            {
+                Finalizer.Instance.ErrorHandler -= handleFunc;
+            }
+        }
     }
 }
diff --git a/src/runtime/finalizer.cs b/src/runtime/finalizer.cs
@@ -14,15 +14,21 @@ public class CollectArgs : EventArgs
             public int ObjectCount { get; set; }
         }
 
+        public class ErrorArgs : EventArgs
+        {
+            public Exception Error { get; set; }
+        }
+
         public static readonly Finalizer Instance = new Finalizer();
 
         public event EventHandler<CollectArgs> CollectOnce;
+        public event EventHandler<ErrorArgs> ErrorHandler;
 
         private ConcurrentQueue<IDisposable> _objQueue = new ConcurrentQueue<IDisposable>();
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        private delegate int PedingCall(IntPtr arg);
-        private readonly PedingCall _collectAction;
+        private delegate int PendingCall(IntPtr arg);
+        private readonly PendingCall _collectAction;
 
         private bool _pending = false;
         private readonly object _collectingLock = new object();
@@ -87,24 +93,27 @@ internal static void Shutdown()
             }
             Instance.DisposeAll();
             Instance.CallPendingFinalizers();
-            Runtime.PyErr_Clear();
         }
 
         private void AddPendingCollect()
         {
+            if (_pending)
+            {
+                return;
+            }
             lock (_collectingLock)
             {
                 if (_pending)
                 {
                     return;
                 }
                 _pending = true;
-            }
-            IntPtr func = Marshal.GetFunctionPointerForDelegate(_collectAction);
-            if (Runtime.Py_AddPendingCall(func, IntPtr.Zero) != 0)
-            {
-                // Full queue, append next time
-                _pending = false;
+                IntPtr func = Marshal.GetFunctionPointerForDelegate(_collectAction);
+                if (Runtime.Py_AddPendingCall(func, IntPtr.Zero) != 0)
+                {
+                    // Full queue, append next time
+                    _pending = false;
+                }
             }
         }
 
@@ -124,7 +133,19 @@ private void DisposeAll()
             IDisposable obj;
             while (_objQueue.TryDequeue(out obj))
             {
-                obj.Dispose();
+                try
+                {
+                    obj.Dispose();
+                    Runtime.CheckExceptionOccurred();
+                }
+                catch (Exception e)
+                {
+                    // We should not bother the main thread
+                    ErrorHandler?.Invoke(this, new ErrorArgs()
+                    {
+                        Error = e
+                    });
+                }
             }
         }
     }

diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
@@ -199,7 +199,7 @@ public class Runtime
         internal static bool IsPython2 = pyversionnumber < 30;
         internal static bool IsPython3 = pyversionnumber >= 30;
 
-        public static int MainManagedThreadId { get; internal set; }
+        public static int MainManagedThreadId { get; private set; }
 
         /// <summary>
         /// Encoding to use to convert Unicode to/from Managed to Native
@@ -362,10 +362,10 @@ internal static void Initialize()
 
         internal static void Shutdown()
         {
-            Finalizer.Shutdown();
             AssemblyManager.Shutdown();
             Exceptions.Shutdown();
             ImportHook.Shutdown();
+            Finalizer.Shutdown();
             Py_Finalize();
         }