* Serialize CLRObject

* Domain reload test
pythonnet · 80d4fa0bcb342ff8a41e2b7c27c349e32fda381b
commit 80d4fa0bcb342ff8a41e2b7c27c349e32fda381b
diff --git a/src/embed_tests/DomainCode.cs b/src/embed_tests/DomainCode.cs
@@ -0,0 +1,151 @@
+using Python.Runtime;
+using System;
+using System.Diagnostics;
+using System.Reflection;
+
+//
+// The code we'll test. All that really matters is
+//    using GIL { Python.Exec(pyScript); }
+// but the rest is useful for debugging.
+//
+// What matters in the python code is gc.collect and clr.AddReference.
+//
+// Note that the language version is 2.0, so no $"foo{bar}" syntax.
+//
+static class PythonRunner
+{
+    static readonly Action<IntPtr> XIncref;
+    static readonly Action<IntPtr> XDecref;
+
+    static PythonRunner()
+    {
+        const BindingFlags flags = BindingFlags.Static | BindingFlags.NonPublic;
+        MethodInfo incMethod = typeof(Runtime).GetMethod("XIncref", flags);
+        MethodInfo decMethod = typeof(Runtime).GetMethod("XDecref", flags);
+
+        XIncref = (Action<IntPtr>)Delegate.CreateDelegate(typeof(Action<IntPtr>), incMethod);
+        XDecref = (Action<IntPtr>)Delegate.CreateDelegate(typeof(Action<IntPtr>), decMethod);
+    }
+
+    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(mode: ShutdownMode.Reload);
+        using (Py.GIL())
+        {
+            try
+            {
+                var pyScript = string.Format("import clr\n"
+                    + "print('[{0} in python] imported clr')\n"
+                    + "clr.AddReference('System')\n"
+                    + "print('[{0} in python] allocated a clr object')\n"
+                    + "import gc\n"
+                    + "gc.collect()\n"
+                    + "print('[{0} in python] collected garbage')\n",
+                    name);
+                PythonEngine.Exec(pyScript);
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(string.Format("[{0} in .NET] Caught exception: {1}", name, e));
+            }
+        }
+        PythonEngine.BeginAllowThreads();
+    }
+
+
+    private static IntPtr _state;
+
+    public static void InitPython(ShutdownMode mode)
+    {
+        PythonEngine.Initialize(mode: mode);
+        _state = PythonEngine.BeginAllowThreads();
+    }
+
+    public static void ShutdownPython()
+    {
+        PythonEngine.EndAllowThreads(_state);
+        PythonEngine.Shutdown();
+    }
+
+    public static void ShutdownPythonCompletely()
+    {
+        PythonEngine.EndAllowThreads(_state);
+        PythonEngine.ShutdownMode = ShutdownMode.Normal;
+        PythonEngine.Shutdown();
+    }
+
+    public static IntPtr GetTestObject()
+    {
+        try
+        {
+            Type type = typeof(Python.EmbeddingTest.Domain.MyClass);
+            string code = string.Format(@"
+import clr
+clr.AddReference('{0}')
+
+from Python.EmbeddingTest.Domain import MyClass
+obj = MyClass()
+obj.Method()
+obj.StaticMethod()
+", Assembly.GetExecutingAssembly().FullName);
+
+            using (Py.GIL())
+            using (var scope = Py.CreateScope())
+            {
+                scope.Exec(code);
+                using (PyObject obj = scope.Get("obj"))
+                {
+                    Debug.Assert(obj.AsManagedObject(type).GetType() == type);
+                    // We only needs its Python handle
+                    XIncref(obj.Handle);
+                    return obj.Handle;
+                }
+            }
+        }
+        catch (Exception e)
+        {
+            Debug.WriteLine(e);
+            throw;
+        }
+    }
+
+    public static void RunTestObject(IntPtr handle)
+    {
+        using (Py.GIL())
+        {
+
+            using (PyObject obj = new PyObject(handle))
+            {
+                obj.InvokeMethod("Method");
+                obj.InvokeMethod("StaticMethod");
+            }
+        }
+    }
+
+    public static void ReleaseTestObject(IntPtr handle)
+    {
+        using (Py.GIL())
+        {
+            XDecref(handle);
+        }
+    }
+
+    static void OnDomainUnload(object sender, EventArgs e)
+    {
+        Console.WriteLine(string.Format("[{0} in .NET] unloading", AppDomain.CurrentDomain.FriendlyName));
+    }
+}
+
+
+namespace Python.EmbeddingTest.Domain
+{
+    [Serializable]
+    public class MyClass
+    {
+        public void Method() { }
+        public static void StaticMethod() { }
+    }
+}
diff --git a/src/embed_tests/Python.EmbeddingTest.15.csproj b/src/embed_tests/Python.EmbeddingTest.15.csproj
@@ -65,9 +65,13 @@
   <PropertyGroup Condition="$(Configuration.Contains('Release'))">
     <DefineConstants Condition="'$(CustomDefineConstants)' == ''">$(DefineConstants)</DefineConstants>
   </PropertyGroup>
+  <ItemGroup>
+    <Compile Remove="DomainCode.cs" />
+  </ItemGroup>
 
   <ItemGroup>
     <None Include="..\pythonnet.snk" />
+    <None Include="DomainCode.cs" />
     <None Remove="packages.config" />
   </ItemGroup>
 

diff --git a/src/embed_tests/TestDomainReload.cs b/src/embed_tests/TestDomainReload.cs
@@ -1,5 +1,9 @@
 using System;
 using System.CodeDom.Compiler;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
 using System.Reflection;
 using NUnit.Framework;
 using Python.Runtime;
@@ -68,46 +72,40 @@ public static void DomainReloadAndGC()
             PythonEngine.Shutdown();
         }
 
-        //
-        // The code we'll test. All that really matters is
-        //    using GIL { Python.Exec(pyScript); }
-        // but the rest is useful for debugging.
-        //
-        // What matters in the python code is gc.collect and clr.AddReference.
-        //
-        // Note that the language version is 2.0, so no $"foo{bar}" syntax.
-        //
-        const string TestCode = @"
-            using Python.Runtime;
-            using System;
-            class PythonRunner {
-                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(mode: ShutdownMode.Reload);
-                    using (Py.GIL()) {
-                        try {
-                            var pyScript = string.Format(""import clr\n""
-                                + ""print('[{0} in python] imported clr')\n""
-                                + ""clr.AddReference('System')\n""
-                                + ""print('[{0} in python] allocated a clr object')\n""
-                                + ""import gc\n""
-                                + ""gc.collect()\n""
-                                + ""print('[{0} in python] collected garbage')\n"",
-                                name);
-                            PythonEngine.Exec(pyScript);
-                        } catch(Exception e) {
-                            Console.WriteLine(string.Format(""[{0} in .NET] Caught exception: {1}"", name, e));
-                        }
-                    }
-                    PythonEngine.BeginAllowThreads();
-                }
-                static void OnDomainUnload(object sender, EventArgs e) {
-                    System.Console.WriteLine(string.Format(""[{0} in .NET] unloading"", AppDomain.CurrentDomain.FriendlyName));
-                }
-            }";
+        [Test]
+        public static void CrossDomainObject()
+        {
+            IntPtr handle;
+            Type type = typeof(Proxy);
+            Assembly assembly = BuildAssembly("test_domain_reload");
+            {
+                AppDomain domain = CreateDomain("test_domain_reload");
+                var theProxy = (Proxy)domain.CreateInstanceAndUnwrap(
+                        type.Assembly.FullName,
+                        type.FullName);
+                theProxy.InitAssembly(assembly.Location);
+                theProxy.Call("InitPython", ShutdownMode.Reload);
+                handle = (IntPtr)theProxy.Call("GetTestObject");
+                theProxy.Call("ShutdownPython");
+                AppDomain.Unload(domain);
+            }
 
+            {
+                AppDomain domain = CreateDomain("test_domain_reload");
+                var theProxy = (Proxy)domain.CreateInstanceAndUnwrap(
+                        type.Assembly.FullName,
+                        type.FullName);
+                theProxy.InitAssembly(assembly.Location);
+                theProxy.Call("InitPython", ShutdownMode.Reload);
+
+                // handle refering a clr object created in previous domain,
+                // it should had been deserialized and became callable agian.
+                theProxy.Call("RunTestObject", handle);
+                theProxy.Call("ShutdownPythonCompletely");
+                AppDomain.Unload(domain);
+            }
+            Assert.IsTrue(Runtime.Runtime.Py_IsInitialized() == 0);
+        }
 
         /// <summary>
         /// Build an assembly out of the source code above.
@@ -119,15 +117,19 @@ static void OnDomainUnload(object sender, EventArgs e) {
         static Assembly BuildAssembly(string assemblyName)
         {
             var provider = CodeDomProvider.CreateProvider("CSharp");
-
             var compilerparams = new CompilerParameters();
-            compilerparams.ReferencedAssemblies.Add("Python.Runtime.dll");
+            var assemblies = from assembly in AppDomain.CurrentDomain.GetAssemblies()
+                             where !assembly.IsDynamic
+                             select assembly.Location;
+            compilerparams.ReferencedAssemblies.AddRange(assemblies.ToArray());
+
             compilerparams.GenerateExecutable = false;
             compilerparams.GenerateInMemory = false;
-            compilerparams.IncludeDebugInformation = false;
+            compilerparams.IncludeDebugInformation = true;
             compilerparams.OutputAssembly = assemblyName;
 
-            var results = provider.CompileAssemblyFromSource(compilerparams, TestCode);
+            var dir = Path.GetDirectoryName(new StackTrace(true).GetFrame(0).GetFileName());
+            var results = provider.CompileAssemblyFromFile(compilerparams, Path.Combine(dir, "DomainCode.cs"));
             if (results.Errors.HasErrors)
             {
                 var errors = new System.Text.StringBuilder("Compiler Errors:\n");
@@ -168,6 +170,13 @@ public void RunPython()
 
                 Console.WriteLine("[Proxy] Leaving RunPython");
             }
+
+            public object Call(string methodName, params object[] args)
+            {
+                var pythonrunner = theAssembly.GetType("PythonRunner");
+                var method = pythonrunner.GetMethod(methodName);
+                return method.Invoke(null, args);
+            }
         }
 
         /// <summary>
@@ -178,26 +187,11 @@ static void RunAssemblyAndUnload(Assembly assembly, string assemblyName)
         {
             Console.WriteLine($"[Program.Main] === creating domain for assembly {assembly.FullName}");
 
-            // Create the domain. Make sure to set PrivateBinPath to a relative
-            // path from the CWD (namely, 'bin').
-            // See https://stackoverflow.com/questions/24760543/createinstanceandunwrap-in-another-domain
-            var currentDomain = AppDomain.CurrentDomain;
-            var domainsetup = new AppDomainSetup()
-            {
-                ApplicationBase = currentDomain.SetupInformation.ApplicationBase,
-                ConfigurationFile = currentDomain.SetupInformation.ConfigurationFile,
-                LoaderOptimization = LoaderOptimization.SingleDomain,
-                PrivateBinPath = "."
-            };
-            var domain = AppDomain.CreateDomain(
-                    $"My Domain {assemblyName}",
-                    currentDomain.Evidence,
-                domainsetup);
-
+            AppDomain domain = CreateDomain(assemblyName);
             // Create a Proxy object in the new domain, where we want the
             // assembly (and Python .NET) to reside
-            Type type = typeof(Proxy);
             System.IO.Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
+            Type type = typeof(Proxy);
             var theProxy = (Proxy)domain.CreateInstanceAndUnwrap(
                     type.Assembly.FullName,
                     type.FullName);
@@ -214,13 +208,34 @@ static void RunAssemblyAndUnload(Assembly assembly, string assemblyName)
             try
             {
                 Console.WriteLine($"[Program.Main] The Proxy object is valid ({theProxy}). Unexpected domain unload behavior");
+                Assert.Fail($"{theProxy} should be invlaid now");
             }
             catch (AppDomainUnloadedException)
             {
                 Console.WriteLine("[Program.Main] The Proxy object is not valid anymore, domain unload complete.");
             }
         }
 
+        private static AppDomain CreateDomain(string name)
+        {
+            // Create the domain. Make sure to set PrivateBinPath to a relative
+            // path from the CWD (namely, 'bin').
+            // See https://stackoverflow.com/questions/24760543/createinstanceandunwrap-in-another-domain
+            var currentDomain = AppDomain.CurrentDomain;
+            var domainsetup = new AppDomainSetup()
+            {
+                ApplicationBase = currentDomain.SetupInformation.ApplicationBase,
+                ConfigurationFile = currentDomain.SetupInformation.ConfigurationFile,
+                LoaderOptimization = LoaderOptimization.SingleDomain,
+                PrivateBinPath = "."
+            };
+            var domain = AppDomain.CreateDomain(
+                    $"My Domain {name}",
+                    currentDomain.Evidence,
+                domainsetup);
+            return domain;
+        }
+
         /// <summary>
         /// Resolves the assembly. Why doesn't this just work normally?
         /// </summary>

diff --git a/src/runtime/clrobject.cs b/src/runtime/clrobject.cs
@@ -3,6 +3,7 @@
 
 namespace Python.Runtime
 {
+    [Serializable]
     internal class CLRObject : ManagedType
     {
         internal object inst;
@@ -23,7 +24,7 @@ internal CLRObject(object ob, IntPtr tp)
                 }
             }
 
-            GCHandle gc = AllocGCHandle();
+            GCHandle gc = AllocGCHandle(TrackTypes.Wrapper);
             Marshal.WriteIntPtr(py, ObjectOffset.magic(tp), (IntPtr)gc);
             tpHandle = tp;
             pyHandle = py;
@@ -68,5 +69,19 @@ internal static IntPtr GetInstHandle(object ob)
             CLRObject co = GetInstance(ob);
             return co.pyHandle;
         }
+
+        protected override void OnSave()
+        {
+            base.OnSave();
+            Runtime.XIncref(pyHandle);
+        }
+
+        protected override void OnLoad()
+        {
+            base.OnLoad();
+            GCHandle gc = AllocGCHandle(TrackTypes.Wrapper);
+            Marshal.WriteIntPtr(pyHandle, ObjectOffset.magic(tpHandle), (IntPtr)gc);
+            Runtime.XDecref(pyHandle);
+        }
     }
 }