DYN-7691: Add assembly load contexts to packages

src/DynamoCoreWpf/ViewModels/PackageManager/PublishPackageViewModel.cs

@@ -8,6 +8,7 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.Loader;
 using System.Text.RegularExpressions;
 using System.Windows;
 using System.Windows.Forms;
@@ -2218,7 +2219,7 @@ private void AddDllFile(string filename)
             {
                 // we're not sure if this is a managed assembly or not
                 // we try to load it, if it fails - we add it as an additional file
-                var result = PackageLoader.TryLoadFrom(filename, out Assembly assem);
+                var result = PackageLoader.TryLoadFrom(AssemblyLoadContext.Default, filename, out Assembly assem);
                 if (result)
                 {
                     var assemName = assem.GetName().Name;

src/DynamoPackages/Package.cs

@@ -4,6 +4,7 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.Loader;
 using Dynamo.Core;
 using Dynamo.Exceptions;
 using Dynamo.Graph.Nodes.CustomNodes;
@@ -228,6 +229,7 @@ internal IEnumerable<Assembly> NodeLibraries
         /// </summary>
         internal bool RequiresSignedEntryPoints { get; set; }
 
+        internal AssemblyLoadContext AssemblyLoadContext { get; set; } = AssemblyLoadContext.Default;
         #endregion
 
         public Package(string directory, string name, string versionName, string license)
@@ -242,6 +244,8 @@ public Package(string directory, string name, string versionName, string license
             LoadedCustomNodes = new ObservableCollection<CustomNodeInfo>();
             AdditionalFiles = new ObservableCollection<PackageFileInfo>();
             Header = PackageUploadBuilder.NewRequestBody(this);
+
+            AssemblyLoadContext = new PkgAssemblyLoadContext(Name + "@" + VersionName, RootDirectory);
         }
 
         public static Package FromDirectory(string rootPath, ILogger logger)
@@ -374,7 +378,7 @@ internal IEnumerable<PackageAssembly> EnumerateAndLoadAssembliesInBinDirectory()
                 if (shouldLoadFile)
                 {
                     // dll files may be un-managed, skip those
-                    var result = PackageLoader.TryLoadFrom(assemFile.FullName, out assem);
+                    var result = PackageLoader.TryLoadFrom(AssemblyLoadContext, assemFile.FullName, out assem);
                     if (result)
                     {
                         // IsNodeLibrary may fail, we store the warnings here and then show
@@ -586,7 +590,7 @@ internal void UninstallCore(CustomNodeManager customNodeManager, PackageLoader p
                 if (BuiltInPackage)
                 {
                     LoadState.SetAsUnloaded();
-                    Analytics.TrackEvent(Actions.BuiltInPackageConflict, Categories.PackageManagerOperations, $"{Name } {versionName} set unloaded");
+                    Analytics.TrackEvent(Actions.BuiltInPackageConflict, Categories.PackageManagerOperations, $"{Name} {versionName} set unloaded");
 
                     RaisePropertyChanged(nameof(LoadState));
 

src/DynamoPackages/PackageAssemblyLoadContext.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Runtime.Loader;
+
+namespace Dynamo.PackageManager
+{
+    internal class PkgAssemblyLoadContext : AssemblyLoadContext
+    {
+        private readonly string RootDir;
+        private IEnumerable<FileInfo> pkgAssemblies = null;
+        public PkgAssemblyLoadContext(string name, string pkgRoot, bool unloadable = true) : base(name, unloadable)
+        {
+            this.RootDir = pkgRoot;
+        }
+
+        protected override Assembly Load(AssemblyName assemblyName)
+        {
+            pkgAssemblies ??= new DirectoryInfo(RootDir).EnumerateFiles("*.dll", new EnumerationOptions() { RecurseSubdirectories = true });
+
+            var targetAssemName = assemblyName.Name + ".dll";
+            var targetAssembly = pkgAssemblies.FirstOrDefault(x => x.Name == targetAssemName);
+            if (targetAssembly != null)
+            {
+                return LoadFromAssemblyPath(targetAssembly.FullName);
+            }
+            return null;
+        }
+
+        protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
+        {
+            pkgAssemblies ??= new DirectoryInfo(RootDir).EnumerateFiles("*.dll", new EnumerationOptions() { RecurseSubdirectories = true });
+
+            var targetAssemName = unmanagedDllName  + ".dll";
+            var targetAssembly = pkgAssemblies.FirstOrDefault(x => x.Name == targetAssemName);
+            if (targetAssembly != null)
+            {
+                return NativeLibrary.Load(targetAssembly.FullName);
+            }
+            return IntPtr.Zero;
+        }
+    }
+}

src/DynamoPackages/PackageLoader.cs

@@ -1,10 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Runtime.Loader;
 using Dynamo.Core;
 using Dynamo.Exceptions;
 using Dynamo.Extensions;
@@ -37,6 +37,38 @@ public class PackageLoader : LogSourceBase
         internal event Func<string, IExtension> RequestLoadExtension;
         internal event Action<IExtension> RequestAddExtension;
 
+        private HashSet<string> packagesToIsolate = null;
+        internal HashSet<string> PackagesToIsolate
+        {
+            get
+            {
+                if (packagesToIsolate == null)
+                {
+                    packagesToIsolate = [];
+
+                    string pkgs = DynamoModel.FeatureFlags?.CheckFeatureFlag("IsolatePackages", string.Empty);
+                    if (!string.IsNullOrEmpty(pkgs))
+                    {
+                        foreach (var x in pkgs.Split(","))
+                        {
+                            packagesToIsolate.Add(x);
+                        }
+                    }
+
+
+                    pkgs = DynamoModel.FeatureFlags?.CheckFeatureFlag("DoNotIsolatePackages", string.Empty);
+                    if (!string.IsNullOrEmpty(pkgs))
+                    {
+                        foreach (var x in pkgs.Split(","))
+                        {
+                            packagesToIsolate.Remove(x);
+                        }
+                    }
+                }
+                return packagesToIsolate;
+            }
+        }
+
         /// <summary>
         /// This event is raised when a package is first added to the list of packages this package loader is loading.
         /// This event occurs before the package is fully loaded. 
@@ -201,7 +233,12 @@ private void TryLoadPackageIntoLibrary(Package package)
             {
                 var dynamoVersion = VersionUtilities.PartialParse(DynamoModel.Version);
 
-                List<Assembly> blockedAssemblies = new List<Assembly>();
+                if (PackagesToIsolate.Contains(package.Name) || PackagesToIsolate.Contains("All"))
+                {
+                    package.AssemblyLoadContext = new PkgAssemblyLoadContext(package.Name + "@" + package.VersionName, package.RootDirectory);
+                }
+
+                List<Assembly> blockedAssemblies = [];
                 // Try to load node libraries from all assemblies
                 foreach (var assem in package.EnumerateAndLoadAssembliesInBinDirectory())
                 {
@@ -742,14 +779,15 @@ internal static void CleanSharedPublishLoadContext(MetadataLoadContext mlc)
         /// <summary>
         ///     Attempt to load a managed assembly in to LoadFrom context. 
         /// </summary>
+        /// <param name="alc"></param>
         /// <param name="filename">The filename of a DLL</param>
         /// <param name="assem">out Assembly - the passed value does not matter and will only be set if loading succeeds</param>
         /// <returns>Returns true if success, false if BadImageFormatException (i.e. not a managed assembly)</returns>
-        internal static bool TryLoadFrom(string filename, out Assembly assem)
+        internal static bool TryLoadFrom(AssemblyLoadContext alc, string filename, out Assembly assem)
         {
             try
             {
-                assem = Assembly.LoadFrom(filename);
+                assem = alc.LoadFromAssemblyPath(filename);
                 return true;
             }
             catch (FileLoadException e)

src/Tools/DynamoFeatureFlags/FeatureFlagsClient.cs

@@ -85,7 +85,9 @@ internal FeatureFlagsClient(string userkey, string mobileKey = null, bool testMo
                 AllFlags = LdValue.ObjectFrom(new Dictionary<string,LdValue> { { "TestFlag1",LdValue.Of(true) },
                     { "TestFlag2", LdValue.Of("I am a string") },
                     //in tests we want instancing on so we can test it.
-                    { "graphics-primitive-instancing", LdValue.Of(true) } });
+                    { "graphics-primitive-instancing", LdValue.Of(true) },
+                    { "IsolatePackages", LdValue.Of("Package1,Package2") }
+                });
                 return;
             }
 

test/Libraries/PackageManagerTests/PackageLoaderTests.cs

@@ -2,8 +2,10 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
+using System.IO.Packaging;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.Loader;
 using System.Threading;
 using Dynamo.Configuration;
 using Dynamo.Core;
@@ -12,7 +14,10 @@
 using Dynamo.Graph.Nodes.CustomNodes;
 using Dynamo.Graph.Workspaces;
 using Dynamo.Interfaces;
+using Dynamo.Models;
+using Dynamo.Scheduler;
 using Dynamo.Search.SearchElements;
+using DynamoUtilities;
 using Moq;
 using NUnit.Framework;
 
@@ -644,6 +649,56 @@ public void PlacingCustomNodeInstanceFromPackageRetainsCorrectPackageInfoState()
             loader.RequestLoadNodeLibrary -= libraryLoader.LoadLibraryAndSuppressZTSearchImport;
         }
 
+        [Test]
+        public void LoadPackagesInAssemblyIsolation()
+        {
+            // Needed for FeatureFlags
+            Assert.IsTrue(DynamoModel.IsTestMode);
+            Assert.AreEqual(DynamoModel.FeatureFlags.CheckFeatureFlag<string>("IsolatePackages", ""), "Package1,Package2");
+
+            var loader = GetPackageLoader();
+            var libraryLoader = new ExtensionLibraryLoader(CurrentDynamoModel);
+
+            loader.PackagesLoaded += libraryLoader.LoadPackages;
+            loader.RequestLoadNodeLibrary += libraryLoader.LoadLibraryAndSuppressZTSearchImport;
+
+
+            var packageDirectory = Path.Combine(TestDirectory, "testAssemblyIsolation", "Package1");
+            var packageDirectory2 = Path.Combine(TestDirectory, "testAssemblyIsolation", "Package2");
+            var package1 = Package.FromDirectory(packageDirectory, CurrentDynamoModel.Logger);
+            var package2 = Package.FromDirectory(packageDirectory2, CurrentDynamoModel.Logger);
+            loader.LoadPackages([package1, package2]);
+
+            // 2 packages loaded as expected
+            var expectedLoadedPackageNum = 0;
+            foreach (var pkg in loader.LocalPackages)
+            {
+                if (pkg.Name == "Package1" || pkg.Name == "Package2")
+                {
+                    expectedLoadedPackageNum++;
+                }
+            }
+            Assert.AreEqual(2, expectedLoadedPackageNum);
+
+            string openPath = Path.Combine(TestDirectory, @"testAssemblyIsolation\graph.dyn");
+            RunModel(openPath);
+
+            var expectedVersions = 0;
+            var pkgLoadContexts = AssemblyLoadContext.All.Where(x => x.Name.Equals("[email protected]") || x.Name.Equals("[email protected]")).ToList();
+            foreach (var pkg in pkgLoadContexts)
+            {
+                var dep = pkg.Assemblies.FirstOrDefault(x => x.GetName().Name == "Newtonsoft.Json");
+                Assert.IsNotNull(dep);
+
+                var ver = dep.GetName().Version.ToString();
+                // Expected both versions of Newtonsoft to be loaded
+                if (ver == "13.0.0.0" || ver == "8.0.0.0")
+                {
+                    expectedVersions++;
+                }
+            }
+            Assert.AreEqual(2, expectedVersions);
+        }
 
         [Test]
         public void LoadingConflictingCustomNodePackageDoesNotGetLoaded()

test/testAssemblyIsolation/Package1/pkg.json

@@ -0,0 +1 @@
+{"license":"","file_hash":null,"name":"Package1","version":"1.0.0","description":"original package","group":"","keywords":null,"dependencies":[],"contents":"","engine_version":"2.1.0.7840","engine":"dynamo","engine_metadata":"","site_url":"","repository_url":"","contains_binaries":true,"node_libraries":["TestAssemblyIsolation1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"]}

test/testAssemblyIsolation/Package2/pkg.json

@@ -0,0 +1 @@
+{"license":"","file_hash":null,"name":"Package2","version":"1.0.0","description":"original package","group":"","keywords":null,"dependencies":[],"contents":"","engine_version":"2.1.0.7840","engine":"dynamo","engine_metadata":"","site_url":"","repository_url":"","contains_binaries":true,"node_libraries":["TestAssemblyIsolation2, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"]}