Add basic reload shutdown mode

pythonnet · lostmsu · Oct 8, 2020 · Jun 13, 2019 · Jun 13, 2019 · Jun 13, 2019
commit bf3d9f847594e2a5558e83e954614e9a9c0f5982
diff --git a/src/embed_tests/TestDomainReload.cs b/src/embed_tests/TestDomainReload.cs
@@ -85,7 +85,7 @@ public static void RunPython() {
                     AppDomain.CurrentDomain.DomainUnload += OnDomainUnload;
                     string name = AppDomain.CurrentDomain.FriendlyName;
                     Console.WriteLine(string.Format(""[{0} in .NET] In PythonRunner.RunPython"", name));
-                    PythonEngine.Initialize(softShutdown: true);
+                    PythonEngine.Initialize(mode: ShutdownMode.Reload);
                     using (Py.GIL()) {
                         try {
                             var pyScript = string.Format(""import clr\n""

diff --git a/src/runtime/classbase.cs b/src/runtime/classbase.cs
@@ -13,6 +13,7 @@ namespace Python.Runtime
     /// concrete subclasses provide slot implementations appropriate for
     /// each variety of reflected type.
     /// </summary>
+    [Serializable]
     internal class ClassBase : ManagedType
     {
         internal Indexer indexer;

diff --git a/src/runtime/classmanager.cs b/src/runtime/classmanager.cs
@@ -19,7 +19,7 @@ namespace Python.Runtime
     internal class ClassManager
     {
         private static Dictionary<Type, ClassBase> cache;
-        private static Type dtype;
+        private static readonly Type dtype;
 
         private ClassManager()
         {
@@ -81,6 +81,17 @@ private static int OnVisit(IntPtr ob, IntPtr arg)
             return 0;
         }
 
+
+        internal static void StashPush(Stack stack)
+        {
+            stack.Push(cache);
+        }
+
+        internal static void StashPop(Stack stack)
+        {
+            cache = (Dictionary<Type, ClassBase>)stack.Pop();
+        }
+
         /// <summary>
         /// Return the ClassBase-derived instance that implements a particular
         /// reflected managed type, creating it if it doesn't yet exist.
@@ -239,7 +250,7 @@ private static void InitClassBase(Type type, ClassBase impl)
 
         private static ClassInfo GetClassInfo(Type type)
         {
-            var ci = new ClassInfo(type);
+            var ci = new ClassInfo();
             var methods = new Hashtable();
             ArrayList list;
             MethodInfo meth;
@@ -443,7 +454,7 @@ internal class ClassInfo
         public Indexer indexer;
         public Hashtable members;
 
-        internal ClassInfo(Type t)
+        internal ClassInfo()
         {
             members = new Hashtable();
             indexer = null;

diff --git a/src/runtime/classobject.cs b/src/runtime/classobject.cs
@@ -9,6 +9,7 @@ namespace Python.Runtime
     /// Python type objects. Each of those type objects is associated with
     /// an instance of ClassObject, which provides its implementation.
     /// </summary>
+    [Serializable]
     internal class ClassObject : ClassBase
     {
         internal ConstructorBinder binder;

diff --git a/src/runtime/clrobject.cs b/src/runtime/clrobject.cs
@@ -9,6 +9,7 @@ internal class CLRObject : ManagedType
 
         internal CLRObject(object ob, IntPtr tp)
         {
+            System.Diagnostics.Debug.Assert(tp != IntPtr.Zero);
             IntPtr py = Runtime.PyType_GenericAlloc(tp, 0);
 
             long flags = Util.ReadCLong(tp, TypeOffset.tp_flags);

diff --git a/src/runtime/constructorbinder.cs b/src/runtime/constructorbinder.cs
@@ -10,6 +10,7 @@ namespace Python.Runtime
     /// standard MethodBinder because of a difference in invoking constructors
     /// using reflection (which is seems to be a CLR bug).
     /// </summary>
+    [Serializable]
     internal class ConstructorBinder : MethodBinder
     {
         private Type _containingType;

diff --git a/src/runtime/constructorbinding.cs b/src/runtime/constructorbinding.cs
@@ -19,11 +19,14 @@ namespace Python.Runtime
     /// and creating the BoundContructor object which contains ContructorInfo object.
     /// 3) In tp_call, if ctorInfo is not null, ctorBinder.InvokeRaw() is called.
     /// </remarks>
+    [Serializable]
     internal class ConstructorBinding : ExtensionType
     {
         private Type type; // The managed Type being wrapped in a ClassObject
         private IntPtr pyTypeHndl; // The python type tells GetInstHandle which Type to create.
         private ConstructorBinder ctorBinder;
+
+        [NonSerialized]
         private IntPtr repr;
 
         public ConstructorBinding(Type type, IntPtr pyTypeHndl, ConstructorBinder ctorBinder)
@@ -173,6 +176,7 @@ public static int tp_traverse(IntPtr ob, IntPtr visit, IntPtr arg)
     /// An earlier implementation hung the __call__ on the ContructorBinding class and
     /// returned an Incref()ed self.pyHandle from the __get__ function.
     /// </remarks>
+    [Serializable]
     internal class BoundContructor : ExtensionType
     {
         private Type type; // The managed Type being wrapped in a ClassObject

diff --git a/src/runtime/delegateobject.cs b/src/runtime/delegateobject.cs
@@ -8,6 +8,7 @@ namespace Python.Runtime
     /// Each of those type objects is associated an instance of this class,
     /// which provides its implementation.
     /// </summary>
+    [Serializable]
     internal class DelegateObject : ClassBase
     {
         private MethodBinder binder;

diff --git a/src/runtime/eventbinding.cs b/src/runtime/eventbinding.cs
@@ -5,6 +5,7 @@ namespace Python.Runtime
     /// <summary>
     /// Implements a Python event binding type, similar to a method binding.
     /// </summary>
+    [Serializable]
     internal class EventBinding : ExtensionType
     {
         private EventObject e;
@@ -127,5 +128,11 @@ public static int tp_clear(IntPtr ob)
             Runtime.Py_CLEAR(ref self.target);
             return 0;
         }
+
+        protected override void OnSave()
+        {
+            base.OnSave();
+            Runtime.XIncref(target);
+        }
     }
 }
diff --git a/src/runtime/eventobject.cs b/src/runtime/eventobject.cs
@@ -7,6 +7,7 @@ namespace Python.Runtime
     /// <summary>
     /// Implements a Python descriptor type that provides access to CLR events.
     /// </summary>
+    [Serializable]
     internal class EventObject : ExtensionType
     {
         internal string name;

diff --git a/src/runtime/extensiontype.cs b/src/runtime/extensiontype.cs
@@ -8,6 +8,7 @@ namespace Python.Runtime
     /// type object, such as the types that represent CLR methods, fields,
     /// etc. Instances implemented by this class do not support sub-typing.
     /// </summary>
+    [Serializable]
     internal abstract class ExtensionType : ManagedType
     {
         public ExtensionType()
@@ -96,5 +97,19 @@ public static void tp_dealloc(IntPtr ob)
             var self = (ExtensionType)GetManagedObject(ob);
             self.Dealloc();
         }
+
+        protected override void OnSave()
+        {
+            base.OnSave();
+            Runtime.XIncref(pyHandle);
+        }
+
+        protected override void OnLoad()
+        {
+            base.OnLoad();
+            GCHandle gc = AllocGCHandle(true);
+            Marshal.WriteIntPtr(pyHandle, ObjectOffset.magic(tpHandle), (IntPtr)gc);
+            Runtime.PyObject_GC_UnTrack(pyHandle);
+        }
     }
 }
diff --git a/src/runtime/indexer.cs b/src/runtime/indexer.cs
@@ -6,6 +6,7 @@ namespace Python.Runtime
     /// <summary>
     /// Bundles the information required to support an indexer property.
     /// </summary>
+    [Serializable]
     internal class Indexer
     {
         public MethodBinder GetterBinder;

diff --git a/src/runtime/interop.cs b/src/runtime/interop.cs
@@ -311,45 +311,45 @@ public static string GetSlotNameByOffset(int offset)
     internal class TypeFlags
     {
 #if PYTHON2 // these flags were removed in Python 3
-        public static int HaveGetCharBuffer = (1 << 0);
-        public static int HaveSequenceIn = (1 << 1);
-        public static int GC = 0;
-        public static int HaveInPlaceOps = (1 << 3);
-        public static int CheckTypes = (1 << 4);
-        public static int HaveRichCompare = (1 << 5);
-        public static int HaveWeakRefs = (1 << 6);
-        public static int HaveIter = (1 << 7);
-        public static int HaveClass = (1 << 8);
+        public const int HaveGetCharBuffer = (1 << 0);
+        public const int HaveSequenceIn = (1 << 1);
+        public const int GC = 0;
+        public const int HaveInPlaceOps = (1 << 3);
+        public const int CheckTypes = (1 << 4);
+        public const int HaveRichCompare = (1 << 5);
+        public const int HaveWeakRefs = (1 << 6);
+        public const int HaveIter = (1 << 7);
+        public const int HaveClass = (1 << 8);
 #endif
-        public static int HeapType = (1 << 9);
-        public static int BaseType = (1 << 10);
-        public static int Ready = (1 << 12);
-        public static int Readying = (1 << 13);
-        public static int HaveGC = (1 << 14);
+        public const int HeapType = (1 << 9);
+        public const int BaseType = (1 << 10);
+        public const int Ready = (1 << 12);
+        public const int Readying = (1 << 13);
+        public const int HaveGC = (1 << 14);
         // 15 and 16 are reserved for stackless
-        public static int HaveStacklessExtension = 0;
+        public const int HaveStacklessExtension = 0;
         /* XXX Reusing reserved constants */
-        public static int Managed = (1 << 15); // PythonNet specific
-        public static int Subclass = (1 << 16); // PythonNet specific
-        public static int HaveIndex = (1 << 17);
+        public const int Managed = (1 << 15); // PythonNet specific
+        public const int Subclass = (1 << 16); // PythonNet specific
+        public const int HaveIndex = (1 << 17);
         /* Objects support nb_index in PyNumberMethods */
-        public static int HaveVersionTag = (1 << 18);
-        public static int ValidVersionTag = (1 << 19);
-        public static int IsAbstract = (1 << 20);
-        public static int HaveNewBuffer = (1 << 21);
+        public const int HaveVersionTag = (1 << 18);
+        public const int ValidVersionTag = (1 << 19);
+        public const int IsAbstract = (1 << 20);
+        public const int HaveNewBuffer = (1 << 21);
         // TODO: Implement FastSubclass functions
-        public static int IntSubclass = (1 << 23);
-        public static int LongSubclass = (1 << 24);
-        public static int ListSubclass = (1 << 25);
-        public static int TupleSubclass = (1 << 26);
-        public static int StringSubclass = (1 << 27);
-        public static int UnicodeSubclass = (1 << 28);
-        public static int DictSubclass = (1 << 29);
-        public static int BaseExceptionSubclass = (1 << 30);
-        public static int TypeSubclass = (1 << 31);
+        public const int IntSubclass = (1 << 23);
+        public const int LongSubclass = (1 << 24);
+        public const int ListSubclass = (1 << 25);
+        public const int TupleSubclass = (1 << 26);
+        public const int StringSubclass = (1 << 27);
+        public const int UnicodeSubclass = (1 << 28);
+        public const int DictSubclass = (1 << 29);
+        public const int BaseExceptionSubclass = (1 << 30);
+        public const int TypeSubclass = (1 << 31);
 
 #if PYTHON2 // Default flags for Python 2
-        public static int Default = (
+        public const int Default = (
             HaveGetCharBuffer |
             HaveSequenceIn |
             HaveInPlaceOps |
@@ -361,7 +361,7 @@ internal class TypeFlags
             HaveIndex |
             0);
 #elif PYTHON3 // Default flags for Python 3
-        public static int Default = (
+        public const int Default = (
             HaveStacklessExtension |
             HaveVersionTag);
 #endif
@@ -499,9 +499,16 @@ internal static ThunkInfo GetThunk(MethodInfo method, string funcType = null)
             {
                 return ThunkInfo.Empty;
             }
-            Delegate d = Delegate.CreateDelegate(dt, method);
-            var info = new ThunkInfo(d);
-            return info;
+            try
+            {
+                Delegate d = Delegate.CreateDelegate(dt, method);
+                var info = new ThunkInfo(d);
+                return info;
+            }
+            catch (Exception)
+            {
+                throw;
+            }
         }
 
 
@@ -579,7 +586,7 @@ struct PyGC_Head
     }
 
 
-    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
+    [StructLayout(LayoutKind.Sequential)]
     struct PyMethodDef
     {
         public IntPtr ml_name;

diff --git a/src/runtime/managedtype.cs b/src/runtime/managedtype.cs
@@ -11,9 +11,12 @@ namespace Python.Runtime
     /// code. It defines the common fields that associate CLR and Python
     /// objects and common utilities to convert between those identities.
     /// </summary>
+    [Serializable]
     internal abstract class ManagedType
     {
+        [NonSerialized]
         internal GCHandle gcHandle; // Native handle
+
         internal IntPtr pyHandle; // PyObject *
         internal IntPtr tpHandle; // PyType *
 
@@ -190,6 +193,19 @@ protected void TypeClear()
             ClearObjectDict(pyHandle);
         }
 
+        internal void Save()
+        {
+            OnSave();
+        }
+
+        internal void Load()
+        {
+            OnLoad();
+        }
+
+        protected virtual void OnSave() { }
+        protected virtual void OnLoad() { }
+
         protected static void ClearObjectDict(IntPtr ob)
         {
             IntPtr dict = GetObjectDict(ob);
@@ -201,12 +217,12 @@ protected static void ClearObjectDict(IntPtr ob)
             Runtime.XDecref(dict);
         }
 
-        private static IntPtr GetObjectDict(IntPtr ob)
+        protected static IntPtr GetObjectDict(IntPtr ob)
         {
             return Marshal.ReadIntPtr(ob, ObjectOffset.DictOffset(ob));
         }
 
-        private static void SetObjectDict(IntPtr ob, IntPtr value)
+        protected static void SetObjectDict(IntPtr ob, IntPtr value)
         {
             Marshal.WriteIntPtr(ob, ObjectOffset.DictOffset(ob), value);
         }

diff --git a/src/runtime/metatype.cs b/src/runtime/metatype.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections;
+using System.IO;
 using System.Runtime.InteropServices;
 
 namespace Python.Runtime
@@ -13,6 +15,12 @@ internal class MetaType : ManagedType
         private static IntPtr PyCLRMetaType;
         private static SlotsHolder _metaSlotsHodler;
 
+        internal static readonly string[] CustomMethods = new string[]
+        {
+            "__instancecheck__",
+            "__subclasscheck__",
+        };
+
         /// <summary>
         /// Metatype initialization. This bootstraps the CLR metatype to life.
         /// </summary>
@@ -32,6 +40,29 @@ public static void Release()
             _metaSlotsHodler = null;
         }
 
+        internal static void StashPush(Stack stack)
+        {
+            Runtime.XIncref(PyCLRMetaType);
+            stack.Push(PyCLRMetaType);
+        }
+
+        internal static IntPtr StashPop(Stack stack)
+        {
+            PyCLRMetaType = (IntPtr)stack.Pop();
+            _metaSlotsHodler = new SlotsHolder(PyCLRMetaType);
+            TypeManager.InitializeSlots(PyCLRMetaType, typeof(MetaType), _metaSlotsHodler);
+
+            IntPtr mdef = Marshal.ReadIntPtr(PyCLRMetaType, TypeOffset.tp_methods);
+            foreach (var methodName in CustomMethods)
+            {
+                var mi = typeof(MetaType).GetMethod(methodName);
+                ThunkInfo thunkInfo = Interop.GetThunk(mi, "BinaryFunc");
+                _metaSlotsHodler.KeeapAlive(thunkInfo);
+                mdef = TypeManager.WriteMethodDef(mdef, methodName, thunkInfo.Address);
+            }
+            return PyCLRMetaType;
+        }
+
         /// <summary>
         /// Metatype __new__ implementation. This is called to create a new
         /// class / type when a reflected class is subclassed.