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)
@@ -374,7 +376,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 +588,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,49 @@ public class PackageLoader : LogSourceBase
         internal event Func<string, IExtension> RequestLoadExtension;
         internal event Action<IExtension> RequestAddExtension;
 
+        private HashSet<string> packagesToIsolate = null;
+        private HashSet<string> packagesToNotIsolate = null;
+
+        internal bool CanIsolatePackage(string package)
+        {
+            static void populateFlags(string fflagKey, ref HashSet<string> pkgs)
+            {
+                string flags = DynamoModel.FeatureFlags?.CheckFeatureFlag(fflagKey, string.Empty);
+                if (!string.IsNullOrEmpty(flags))
+                {
+                    foreach (var x in flags.Split(","))
+                    {
+                        pkgs.Add(x);
+                    }
+                }
+            }
+
+            if (packagesToIsolate == null)
+            {
+                packagesToIsolate = [];
+                populateFlags("IsolatePackages", ref packagesToIsolate);
+            }
+
+            if (packagesToNotIsolate == null)
+            {
+                packagesToNotIsolate = [];
+                populateFlags("DoNotIsolatePackages", ref packagesToNotIsolate);
+            }
+
+            // NotIsolate has the highest priority.
+            if (packagesToNotIsolate.Contains(package) || packagesToNotIsolate.Contains("All"))
+            {
+                return false;
+            }
+
+            if (packagesToIsolate.Contains(package) || packagesToIsolate.Contains("All"))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
         /// <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 +244,12 @@ private void TryLoadPackageIntoLibrary(Package package)
             {
                 var dynamoVersion = VersionUtilities.PartialParse(DynamoModel.Version);
 
-                List<Assembly> blockedAssemblies = new List<Assembly>();
+                if (CanIsolatePackage(package.Name))
+                {
+                    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 +790,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/DynamoUtilities/Properties/AssemblyInfo.cs

@@ -29,3 +29,4 @@
 [assembly: InternalsVisibleTo("LibraryViewExtensionWebView2")]
 [assembly: InternalsVisibleTo("Notifications")]
 [assembly: InternalsVisibleTo("SystemTestServices")]
+[assembly: InternalsVisibleTo("PackageManagerTests")]

src/Tools/DynamoFeatureFlags/FeatureFlagsClient.cs

@@ -85,7 +85,10 @@ 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,Package") },
+                    { "DoNotIsolatePackages", LdValue.Of("Package") }
+                });
                 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,7 +649,66 @@ public void PlacingCustomNodeInstanceFromPackageRetainsCorrectPackageInfoState()
             loader.RequestLoadNodeLibrary -= libraryLoader.LoadLibraryAndSuppressZTSearchImport;
         }
 
-
+        [Test]
+        public void LoadPackagesInAssemblyIsolation()
+        {
+            // Needed for FeatureFlags
+            Assert.IsTrue(DynamoModel.IsTestMode);
+            Assert.AreEqual("Package1,Package2,Package", DynamoModel.FeatureFlags.CheckFeatureFlag<string>("IsolatePackages", ""));
+            Assert.AreEqual("Package", DynamoModel.FeatureFlags.CheckFeatureFlag<string>("DoNotIsolatePackages", ""));
+
+
+            var loader = GetPackageLoader();
+            var libraryLoader = new ExtensionLibraryLoader(CurrentDynamoModel);
+
+            loader.PackagesLoaded += libraryLoader.LoadPackages;
+
+            var packageDirectory = Path.Combine(TestDirectory, "testAssemblyIsolation", "Package1");
+            var packageDirectory2 = Path.Combine(TestDirectory, "testAssemblyIsolation", "Package2");
+            var packageDirectory3 = Path.Combine(TestDirectory, "pkgs", "Package");
+            var package1 = Package.FromDirectory(packageDirectory, CurrentDynamoModel.Logger);
+            var package2 = Package.FromDirectory(packageDirectory2, CurrentDynamoModel.Logger);
+            var package3 = Package.FromDirectory(packageDirectory3, CurrentDynamoModel.Logger);
+            loader.LoadPackages([package1, package2, package3]);
+
+            loader.PackagesLoaded -= libraryLoader.LoadPackages;
+
+            // 2 packages loaded as expected
+            var expectedLoadedPackageNum = 0;
+            foreach (var pkg in loader.LocalPackages)
+            {
+                if (pkg.Name == "Package1" || pkg.Name == "Package2" || pkg.Name == "Package")
+                {
+                    expectedLoadedPackageNum++;
+                }
+            }
+            Assert.AreEqual(3, 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);
+
+            // Make sure the "DoNotIsolatePackages" fflag puts the pacakge in the default load context(i.e does not isolate it)
+            var contexts = AssemblyLoadContext.All.Where(l => l.Assemblies.FirstOrDefault(x => x.GetName().Name == "Package") != null).ToList();
+            Assert.AreEqual(1, contexts.Count);
+            Assert.True(contexts[0] == AssemblyLoadContext.Default);
+        }
+
         [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"]}