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/DynamoFeatureFlagsManager.cs

@@ -2,16 +2,17 @@
 using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Diagnostics;
 using System.IO;
-using System.Reflection;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace DynamoUtilities
 {
 
+    internal interface IFFlags
+    {
+        internal T CheckFeatureFlag<T>(DynamoFeatureFlagsManager mgr, string featureFlagKey, T defaultval);
+    }
 
     /// <summary>
     /// A wrapper around the DynamoFeatureFlags CLI tool.
@@ -20,9 +21,21 @@ namespace DynamoUtilities
     /// </summary>
     internal class DynamoFeatureFlagsManager : CLIWrapper
     {
+        // Utility class that supports mocking during tests
+        class FFlags : IFFlags
+        {
+            T IFFlags.CheckFeatureFlag<T>(DynamoFeatureFlagsManager mgr, string featureFlagKey, T defaultval)
+            {
+                return mgr.CheckFeatureFlagInternal(featureFlagKey, defaultval);
+            }
+        }
+
+        // Useful for mocking in tests
+        internal IFFlags flags { get; set; } = new FFlags();
         private string relativePath = Path.Combine("DynamoFeatureFlags", "DynamoFeatureFlags.exe");
         private Dictionary<string, object> AllFlagsCache { get; set; }//TODO lock is likely overkill.
         private SynchronizationContext syncContext;
+        private readonly bool testmode = false;
         internal static event Action FlagsRetrieved;
 
         //TODO(DYN-6464)- remove this field!.
@@ -43,8 +56,10 @@ internal class DynamoFeatureFlagsManager : CLIWrapper
         /// <param name="syncContext">context used for raising FlagRetrieved event.</param>
         /// <param name="testmode">will not contact feature flag service in testmode, will respond with defaults.</param>
         internal DynamoFeatureFlagsManager(string userkey, SynchronizationContext syncContext, bool testmode=false)
-        {  
+        {
             this.syncContext = syncContext;
+            this.testmode = testmode;
+
             //dont pass userkey arg if null/empty
             var userkeyarg = $"-u {userkey}";
             var testmodearg = string.Empty;
@@ -62,7 +77,6 @@ internal DynamoFeatureFlagsManager(string userkey, SynchronizationContext syncCo
 
         internal void CacheAllFlags()
         {
-
             //wait for response
             var dataFromCLI = GetData(featureFlagTimeoutMs);    
             //convert from json string to dictionary.
@@ -91,6 +105,13 @@ internal void CacheAllFlags()
         /// <param name="defaultval">Currently the flag and default val MUST be a bool or string.</param>
         /// <returns></returns>
         internal T CheckFeatureFlag<T>(string featureFlagKey, T defaultval)
+        {
+            // with testmode = true, the call goes through an interface so that we can intercept it with Mock
+            // with testmode = false, the call simply goes to the CheckFeatureFlagInternal
+            return testmode ? flags.CheckFeatureFlag(this, featureFlagKey, defaultval) : CheckFeatureFlagInternal(featureFlagKey, defaultval);
+        }
+
+        private T CheckFeatureFlagInternal<T>(string featureFlagKey, T defaultval)
         {
             if(!(defaultval is bool || defaultval is string)){
                 throw new ArgumentException("unsupported flag type", defaultval.GetType().ToString());

src/DynamoUtilities/Properties/AssemblyInfo.cs

@@ -29,3 +29,6 @@
 [assembly: InternalsVisibleTo("LibraryViewExtensionWebView2")]
 [assembly: InternalsVisibleTo("Notifications")]
 [assembly: InternalsVisibleTo("SystemTestServices")]
+[assembly: InternalsVisibleTo("PackageManagerTests")]
+//DynamicProxyGenAssembly2 is used by Mock to allow stubbing internal interfaces
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]

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,74 @@ public void PlacingCustomNodeInstanceFromPackageRetainsCorrectPackageInfoState()
             loader.RequestLoadNodeLibrary -= libraryLoader.LoadLibraryAndSuppressZTSearchImport;
         }
 
-
+        [Test]
+        public void LoadPackagesInAssemblyIsolation()
+        {
+            var ff = new Mock<DynamoUtilities.IFFlags>();
+            DynamoModel.FeatureFlags.flags = ff.Object;
+            ff.Setup(x => x.CheckFeatureFlag<string>(DynamoModel.FeatureFlags, "IsolatePackages", "")).Returns(() => "Package1,Package2,Package");
+            ff.Setup(x => x.CheckFeatureFlag<string>(DynamoModel.FeatureFlags, "DoNotIsolatePackages", "")).Returns(() => "Package");
+
+            // 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 pathManager = new Mock<Dynamo.Interfaces.IPathManager>();
+            pathManager.SetupGet(x => x.PackagesDirectories).Returns(
+                () => new List<string> { PackagesDirectory });
+
+            var loader = new PackageLoader(pathManager.Object);
+            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"]}