Refactor mono loading for better defaults

- Use SGen garbage collector by default
- Use default installation paths for Windows and macOS

Author: filmor

clr_loader/__init__.py

@@ -1,28 +1,36 @@
 from typing import Dict, Optional
 
 from .wrappers import Runtime
+from .util.find import find_libmono, find_dotnet_root
 
 __all__ = ["get_mono", "get_netfx", "get_coreclr"]
 
 
 def get_mono(
     domain: Optional[str] = None,
     config_file: Optional[str] = None,
-    path: Optional[str] = None,
-    gc: Optional[str] = None,
+    libmono: Optional[str] = None,
+    sgen: bool = True,
 ) -> Runtime:
     from .mono import Mono
 
-    impl = Mono(domain=domain, config_file=config_file, path=path, gc=gc)
+    if libmono is None:
+        libmono = find_libmono(sgen)
+
+    impl = Mono(domain=domain, config_file=config_file, libmono=libmono)
     return Runtime(impl)
 
 
 def get_coreclr(
-    runtime_config: str, dotnet_root: Optional[str] = None,
-    properties: Optional[Dict[str, str]] = None
+    runtime_config: str,
+    dotnet_root: Optional[str] = None,
+    properties: Optional[Dict[str, str]] = None,
 ) -> Runtime:
     from .hostfxr import DotnetCoreRuntime
 
+    if dotnet_root is None:
+        dotnet_root = find_dotnet_root()
+
     impl = DotnetCoreRuntime(runtime_config=runtime_config, dotnet_root=dotnet_root)
     if properties:
         for key, value in properties:

clr_loader/ffi/__init__.py

@@ -33,13 +33,6 @@ def load_mono(path: Optional[str] = None, gc: Optional[str] = None):
     if sys.platform.startswith("linux"):
         ffi.dlopen("stdc++", ffi.RTLD_GLOBAL)
 
-    if path is None:
-        from ctypes.util import find_library
-
-        path = find_library(f"mono{gc or ''}-2.0")
-        if path is None:
-            raise RuntimeError("Could not find libmono")
-
     return ffi.dlopen(path, ffi.RTLD_GLOBAL)
 
 

clr_loader/hostfxr.py

@@ -1,6 +1,5 @@
 import os
 import sys
-from typing import Optional
 
 from .ffi import ffi, load_hostfxr
 from .util import check_result, find_dotnet_root
@@ -9,7 +8,7 @@
 
 
 class DotnetCoreRuntime:
-    def __init__(self, runtime_config: str, dotnet_root: Optional[str] = None):
+    def __init__(self, runtime_config: str, dotnet_root: str):
         self._dotnet_root = dotnet_root or find_dotnet_root()
         self._dll = load_hostfxr(self._dotnet_root)
         self._is_finalized = False

clr_loader/mono.py

@@ -11,9 +11,10 @@
 
 
 class Mono:
-    def __init__(self, domain=None, config_file=None, path=None, gc=None):
+    def __init__(self, libmono, domain=None, config_file=None):
         self._assemblies = {}
-        initialize(config_file=config_file, path=path, gc=gc)
+
+        initialize(config_file=config_file, libmono=libmono)
 
         if domain is None:
             self._domain = _ROOT_DOMAIN
@@ -80,10 +81,10 @@ def __call__(self, ptr, size):
         return unboxed[0]
 
 
-def initialize(config_file, path=None, gc=None):
+def initialize(config_file: str, libmono: str) -> None:
     global _MONO, _ROOT_DOMAIN
     if _MONO is None:
-        _MONO = load_mono(path=path, gc=gc)
+        _MONO = load_mono(libmono)
 
         if config_file is None:
             config_file = ffi.NULL

clr_loader/util/find.py

@@ -42,3 +42,32 @@ def find_dotnet_root() -> str:
         pass
 
     return os.path.dirname(dotnet_path)
+
+
+def find_libmono(sgen: bool = True) -> str:
+    unix_name = f"mono{'sgen' if sgen else ''}-2.0"
+    if sys.platform == "win32":
+        if sys.maxsize > 2 ** 32:
+            prog_files = os.environ.get("ProgramFiles")
+        else:
+            prog_files = os.environ.get("ProgramFiles(x86)")
+
+        # Ignore sgen on Windows, the main installation only contains this DLL
+        path = fr"{prog_files}\Mono\bin\mono-2.0-sgen.dll"
+
+    elif sys.platform == "darwin":
+        path = (
+            "/Library/Frameworks/Mono.framework/Versions/"
+            "Current"
+            f"/lib/libmono{unix_name}.dylib"
+        )
+
+    else:
+        from ctypes.util import find_library
+
+        path = find_library(unix_name)
+
+    if path is None:
+        raise RuntimeError("Could not find libmono")
+    
+    return path

tests/test_common.py

@@ -8,10 +8,12 @@
 def example_netstandard(tmpdir_factory):
     return build_example(tmpdir_factory, "netstandard20")
 
+
 @pytest.fixture(scope="session")
 def example_netcore(tmpdir_factory):
     return build_example(tmpdir_factory, "netcoreapp31")
 
+
 def build_example(tmpdir_factory, framework):
     out = str(tmpdir_factory.mktemp(f"example-{framework}"))
     proj_path = os.path.join(os.path.dirname(__file__), "../example")
@@ -24,21 +26,7 @@ def build_example(tmpdir_factory, framework):
 def test_mono(example_netstandard):
     from clr_loader import get_mono
 
-    if sys.platform == 'win32':
-        if sys.maxsize > 2**32:
-            prog_files = os.environ.get("ProgramFiles")
-        else:
-            prog_files = os.environ.get("ProgramFiles(x86)")
-
-        path = fr"{prog_files}\Mono\bin\mono-2.0-sgen.dll"
-
-    elif sys.platform == "darwin":
-        path = "/Library/Frameworks/Mono.framework/Versions/Current/lib/libmono-2.0.dylib"
-
-    else:
-        path = None
-
-    mono = get_mono(path=path)
+    mono = get_mono()
     asm = mono.get_assembly(os.path.join(example_netstandard, "example.dll"))
 
     run_tests(asm)
@@ -53,7 +41,9 @@ def test_coreclr(example_netcore):
     run_tests(asm)
 
 
-@pytest.mark.skipif(sys.platform != 'win32', reason=".NET Framework only exists on Windows")
+@pytest.mark.skipif(
+    sys.platform != "win32", reason=".NET Framework only exists on Windows"
+)
 def test_netfx(example_netstandard):
     from clr_loader import get_netfx
 
@@ -68,4 +58,3 @@ def run_tests(asm):
     test_data = b"testy mctestface"
     res = func(test_data)
     assert res == len(test_data)
-