Ejemplo n.º 1
0
        /// <summary>
        /// Update the PatternAssignmentRules section for the current AppDomain.
        /// </summary>
        /// <param name="adConfig"></param>
        private void UpdatePatternAssignmentRules(AppDomains adConfig, string appDomainName, string assemblyNameRegexes)
        {
            if (string.IsNullOrWhiteSpace(assemblyNameRegexes))
            {
                return;
            }

            List <PatternAssignmentRule> pars = adConfig.PatternAssignmentRules.ToList();

            string[] assemblyNameRegexesSplit = assemblyNameRegexes.Split(';');

            foreach (string assemblyNameRegex in assemblyNameRegexesSplit)
            {
                PatternAssignmentRule par = FindMatchOnAssemblyPatternAppDomain(pars, assemblyNameRegex, appDomainName);

                if (par == null)
                {
                    par = new PatternAssignmentRule();
                    par.AssemblyNamePattern = assemblyNameRegex;
                    par.AppDomainName       = appDomainName;
                    pars.Add(par);
                }
            }

            adConfig.PatternAssignmentRules = pars.ToArray();
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Update the ExactAssignmentRules section for the current AppDomain.
        /// </summary>
        /// <param name="adConfig"></param>
        private void UpdateExactAssignmentRules(AppDomains adConfig, string appDomainName, string assemblyNames)
        {
            if (string.IsNullOrWhiteSpace(assemblyNames))
            {
                return;
            }

            List <ExactAssignmentRule> ears = adConfig.ExactAssignmentRules.ToList();

            string[] assemblyNamesSplit = assemblyNames.Split(';');

            foreach (string assemblyName in assemblyNamesSplit)
            {
                ExactAssignmentRule ear = FindMatchOnAssemblyAppDomain(ears, assemblyName, appDomainName);

                if (ear == null)
                {
                    ear = new ExactAssignmentRule();
                    ear.AssemblyName  = assemblyName;
                    ear.AppDomainName = appDomainName;
                    ears.Add(ear);
                }
            }

            adConfig.ExactAssignmentRules = ears.ToArray();
        }
Ejemplo n.º 3
0
        private void RemovePatternAssignmentRules(AppDomains adConfig, string appDomainName)
        {
            List <PatternAssignmentRule> pars = adConfig.PatternAssignmentRules.ToList();

            pars.RemoveAll(par => (string.Compare(par.AppDomainName, appDomainName, true) == 0));

            adConfig.PatternAssignmentRules = pars.ToArray();
        }
Ejemplo n.º 4
0
        private void RemoveExactAssignmentRules(AppDomains adConfig, string appDomainName)
        {
            List <ExactAssignmentRule> ears = adConfig.ExactAssignmentRules.ToList();

            ears.RemoveAll(ear => (string.Compare(ear.AppDomainName, appDomainName, true) == 0));

            adConfig.ExactAssignmentRules = ears.ToArray();
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Update the assignment rules section for the current AppDomain.
        /// </summary>
        private void UpdateAssignmentRules(AppDomains adConfig, string appDomainName, string assemblyNameRegexes, string assemblyNames)
        {
            if (string.IsNullOrWhiteSpace(assemblyNameRegexes) && string.IsNullOrWhiteSpace(assemblyNames))
            {
                assemblyNameRegexes = _defaultAssemblyNameRegexes;
            }

            RemoveAssignmentRules(adConfig, appDomainName);
            UpdateExactAssignmentRules(adConfig, appDomainName, assemblyNames);
            UpdatePatternAssignmentRules(adConfig, appDomainName, assemblyNameRegexes);
        }
Ejemplo n.º 6
0
        public bool UnloadAppDomain(string friendlyName)
        {
            AppDomain value = AppDomains.FirstOrDefault(ad => ad.FriendlyName.Equals(friendlyName));

            if (value == null)
            {
                return(false);
            }
            UnloadAppDomain(value);
            return(true);
        }
Ejemplo n.º 7
0
        private void UnloadAppDomain(AppDomain domain)
        {
            string domainFriendlyName = domain.FriendlyName;

            Instances.RemoveAll(instance => instance.Key.Equals(domainFriendlyName));
            if (AppDomains.Contains(domain))
            {
                AppDomains.Remove(domain);
            }
            if (!domain.IsFinalizingForUnload())
            {
                AppDomain.Unload(domain);
                // HARD-CODED constant
                Tracer.Instance.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "AppDomain {0} unloaded.", domainFriendlyName);
            }
        }
Ejemplo n.º 8
0
        public override IEnumerable <ClrModule> EnumerateModules()
        {
            IEnumerable <ClrModule> modules = AppDomains.SelectMany(ad => ad.Modules);

            if (SharedDomain != null)
            {
                modules = SharedDomain.Modules.Concat(modules);
            }

            if (SystemDomain != null)
            {
                modules = SystemDomain.Modules.Concat(modules);
            }

            return(modules);
        }
Ejemplo n.º 9
0
 public static bool UnloadAddIn(string AddInID)
 {
     try
     {
         if (AppDomains.ContainsKey(AddInID))
         {
             AppDomain.Unload(AppDomains[AddInID]);
             return(true);
         }
         else
         {
             throw new Exception("应用程序域已被卸载!");
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Ejemplo n.º 10
0
        public T CreateNewAppDomain <T>(string domainName) where T : class
        {
            // ReSharper disable once InvertIf
            if (AppDomains.FirstOrDefault(ad => ad.FriendlyName.Equals(domainName)) == null)
            {
                AppDomain domain = AppDomain.CreateDomain(domainName, AppDomain.CurrentDomain.Evidence, _appDomainSetup);
                AppDomains.Add(domain);

                // HARD-CODED constant
                Tracer.Instance.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "AppDomain {0} created.", domainName);

                //! This bypasses the Main method as it's not executing it.
                object instance = domain.CreateInstanceAndUnwrap(typeof(T).Assembly.FullName, typeof(T).FullName);
                Instances.Add(new KeyValuePair <string, object>(domainName, instance));

                // HARD-CODED constant
                Tracer.Instance.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "AppDomain Instance {0} created.", typeof(T).FullName);
                //x return AppDomainInstances.Last() as T;
                return(instance as T);
            }
            return(null);
        }
Ejemplo n.º 11
0
        private static void HappyPath()
        {
            var ad  = AppDomains.Use("Container");
            var rlt = ad.Execute((pars) =>
            {
                Console.WriteLine(AppDomain.CurrentDomain.FriendlyName);

                LoadPlugin();

                return(pars[0]);
            }, "This is parameter");

            Console.WriteLine($"{AppDomain.CurrentDomain.FriendlyName}: {rlt.Result}");
            Console.ReadKey();

            AppDomains.Unload("Container");

            Console.WriteLine("Press any key to reload Container ...");
            Console.ReadKey();

            Thread th = new Thread(new ThreadStart(() =>
            {
                Thread.Sleep(2000);
                AppDomains.Use("Container");
            }));

            th.Start();
            Console.WriteLine("Requiring Container ...");
            ad = AppDomains.Require("Container");
            ad.Execute((pars) =>
            {
                Console.WriteLine("Container reload completed");
                LoadPlugin();
                return(null);
            });
            Console.WriteLine("Press any key to exit ...");
            Console.ReadKey();
        }
Ejemplo n.º 12
0
        public static AppDomain CreateAddInAppDomain(string AddInID)
        {
            try
            {
                string path = System.AppDomain.CurrentDomain.BaseDirectory + "\\bin\\AddIn.dll";

                //Create evidence for the new application domain from evidence of
                Evidence adEvidence = AppDomain.CurrentDomain.Evidence;

                AppDomainSetup ads = GetAppDomainSetup();

                AppDomain NewDomain = AppDomain.CreateDomain(AddInID, adEvidence, ads);
                //string friendlyName = myDomain.FriendlyName;
                if (!AppDomains.ContainsKey(AddInID))
                {
                    AppDomains.Add(AddInID, NewDomain);
                }
                else
                {
                    AppDomains[AddInID] = NewDomain;
                }
                //IObject obj = (IObject)myDomain.CreateInstanceFromAndUnwrap(path, "Interface.AddInLoader");
                IAddInLoader obj = (IAddInLoader)NewDomain.CreateInstanceFromAndUnwrap(path, "AddIn.Entity.AddInLoader");
                if (!Loaders.ContainsKey(AddInID))
                {
                    Loaders.Add(AddInID, obj);
                }
                else
                {
                    Loaders[AddInID] = obj;
                }
                return(NewDomain);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Ejemplo n.º 13
0
 /// <summary>
 /// Gets the AppDomain specified by the name. If multiple AppDomains have same name, it will throw exception.
 /// If there is no such AppDomain, it will return null.
 /// </summary>
 /// <param name="appDomainName">The application domain name.</param>
 public AppDomain GetAppDomainByName(string appDomainName)
 {
     return(AppDomains.SingleOrDefault(ad => ad.Name == appDomainName));
 }
Ejemplo n.º 14
0
 private void RemoveAssignmentRules(AppDomains adConfig, string appDomainName)
 {
     RemoveExactAssignmentRules(adConfig, appDomainName);
     RemovePatternAssignmentRules(adConfig, appDomainName);
 }
Ejemplo n.º 15
0
        public override bool Execute()
        {
            Guard.ArgumentNotNull(nameof(Assemblies), Assemblies);

            RemotingUtility.CleanUpRegisteredChannels();

            XElement?assembliesElement = null;

            if (NeedsXml)
            {
                assembliesElement = new XElement("assemblies");
            }

            var appDomains = default(AppDomainSupport?);

            switch (AppDomains?.ToLowerInvariant())
            {
            case null:
                break;

            case "ifavailable":
                appDomains = AppDomainSupport.IfAvailable;
                break;

            case "true":
            case "required":
                appDomains = AppDomainSupport.Required;
                break;

            case "false":
            case "denied":
                appDomains = AppDomainSupport.Denied;
                break;

            default:
                Log.LogError("AppDomains value '{0}' is invalid: must be 'ifavailable', 'required', or 'denied'", AppDomains);
                return(false);
            }

            switch (MaxParallelThreads)
            {
            case null:
            case "default":
                break;

            case "unlimited":
                maxThreadCount = -1;
                break;

            default:
                int threadValue;
                if (!int.TryParse(MaxParallelThreads, out threadValue) || threadValue < 1)
                {
                    Log.LogError("MaxParallelThreads value '{0}' is invalid: must be 'default', 'unlimited', or a positive number", MaxParallelThreads);
                    return(false);
                }

                maxThreadCount = threadValue;
                break;
            }

            var originalWorkingFolder          = Directory.GetCurrentDirectory();
            var internalDiagnosticsMessageSink = DiagnosticMessageSink.ForInternalDiagnostics(Log, InternalDiagnosticMessages);

            using (AssemblyHelper.SubscribeResolveForAssembly(typeof(xunit), internalDiagnosticsMessageSink))
            {
                var reporter = GetReporter();
                if (reporter == null)
                {
                    return(false);
                }

                try
                {
                    logger = new MSBuildLogger(Log);
                    reporterMessageHandler = reporter.CreateMessageHandler(logger, internalDiagnosticsMessageSink).GetAwaiter().GetResult();

                    if (!NoLogo)
                    {
                        Log.LogMessage(MessageImportance.High, $"xUnit.net v3 MSBuild Runner v{ThisAssembly.AssemblyInformationalVersion} ({IntPtr.Size * 8}-bit {RuntimeInformation.FrameworkDescription})");
                    }

                    var project = new XunitProject();
                    foreach (var assembly in Assemblies)
                    {
                        var assemblyFileName = assembly.GetMetadata("FullPath");
                        var configFileName   = assembly.GetMetadata("ConfigFile");
                        if (configFileName != null && configFileName.Length == 0)
                        {
                            configFileName = null;
                        }

                        var targetFramework = AssemblyUtility.GetTargetFramework(assemblyFileName);
                        var projectAssembly = new XunitProjectAssembly(project)
                        {
                            AssemblyFilename = assemblyFileName,
                            ConfigFilename   = configFileName,
                            TargetFramework  = targetFramework
                        };

                        ConfigReader.Load(projectAssembly.Configuration, assemblyFileName, configFileName);

                        if (shadowCopy.HasValue)
                        {
                            projectAssembly.Configuration.ShadowCopy = shadowCopy;
                        }

                        project.Add(projectAssembly);
                    }

                    if (WorkingFolder != null)
                    {
                        Directory.SetCurrentDirectory(WorkingFolder);
                    }

                    var clockTime = Stopwatch.StartNew();

                    if (!parallelizeAssemblies.HasValue)
                    {
                        parallelizeAssemblies = project.All(assembly => assembly.Configuration.ParallelizeAssemblyOrDefault);
                    }

                    if (parallelizeAssemblies.GetValueOrDefault())
                    {
                        var tasks   = project.Assemblies.Select(assembly => Task.Run(() => ExecuteAssembly(assembly, appDomains).AsTask()));
                        var results = Task.WhenAll(tasks).GetAwaiter().GetResult();
                        foreach (var assemblyElement in results.WhereNotNull())
                        {
                            assembliesElement !.Add(assemblyElement);
                        }
                    }
                    else
                    {
                        foreach (var assembly in project.Assemblies)
                        {
                            var assemblyElement = ExecuteAssembly(assembly, appDomains);
                            if (assemblyElement != null)
                            {
                                assembliesElement !.Add(assemblyElement);
                            }
                        }
                    }

                    clockTime.Stop();

                    if (assembliesElement != null)
                    {
                        assembliesElement.Add(new XAttribute("timestamp", DateTime.Now.ToString(CultureInfo.InvariantCulture)));
                    }

                    if (completionMessages.Count > 0)
                    {
                        var summaries = new TestExecutionSummaries {
                            ElapsedClockTime = clockTime.Elapsed
                        };
                        foreach (var completionMessage in completionMessages.OrderBy(kvp => kvp.Key))
                        {
                            summaries.Add(completionMessage.Key, completionMessage.Value);
                        }
                        reporterMessageHandler.OnMessage(summaries);
                    }
                }
                finally
                {
                    reporter.DisposeAsync().GetAwaiter().GetResult();
                }
            }

            Directory.SetCurrentDirectory(WorkingFolder ?? originalWorkingFolder);

            if (NeedsXml && assembliesElement != null)
            {
                if (Xml != null)
                {
                    TransformFactory.Transform("xml", assembliesElement, Xml.GetMetadata("FullPath"));
                }

                if (XmlV1 != null)
                {
                    TransformFactory.Transform("xmlv1", assembliesElement, XmlV1.GetMetadata("FullPath"));
                }

                if (Html != null)
                {
                    TransformFactory.Transform("html", assembliesElement, Html.GetMetadata("FullPath"));
                }

                if (NUnit != null)
                {
                    TransformFactory.Transform("nunit", assembliesElement, NUnit.GetMetadata("FullPath"));
                }

                if (JUnit != null)
                {
                    TransformFactory.Transform("junit", assembliesElement, JUnit.GetMetadata("FullPath"));
                }
            }

            // ExitCode is set to 1 for test failures and -1 for Exceptions.
            return(ExitCode == 0 || (ExitCode == 1 && IgnoreFailures));
        }
Ejemplo n.º 16
0
        public override bool Execute()
        {
            RemotingUtility.CleanUpRegisteredChannels();

            XElement assembliesElement = null;
            var      environment       = $"{IntPtr.Size * 8}-bit {CrossPlatform.Version}";

            if (NeedsXml)
            {
                assembliesElement = new XElement("assemblies");
            }

            var appDomains = default(AppDomainSupport?);

            switch (AppDomains?.ToLowerInvariant())    // Using ToLowerInvariant() here for back compat for when this was a boolean
            {
            case null:
                break;

            case "ifavailable":
                appDomains = AppDomainSupport.IfAvailable;
                break;

            case "true":
            case "required":
                appDomains = AppDomainSupport.Required;
                break;

            case "false":
            case "denied":
                appDomains = AppDomainSupport.Denied;
                break;

            default:
                Log.LogError("AppDomains value '{0}' is invalid: must be 'ifavailable', 'required', or 'denied'", AppDomains);
                return(false);
            }

            switch (MaxParallelThreads)
            {
            case null:
            case "default":
                break;

            case "unlimited":
                maxThreadCount = -1;
                break;

            default:
                int threadValue;
                if (!int.TryParse(MaxParallelThreads, out threadValue) || threadValue < 1)
                {
                    Log.LogError("MaxParallelThreads value '{0}' is invalid: must be 'default', 'unlimited', or a positive number", MaxParallelThreads);
                    return(false);
                }

                maxThreadCount = threadValue;
                break;
            }

            var originalWorkingFolder          = Directory.GetCurrentDirectory();
            var internalDiagnosticsMessageSink = DiagnosticMessageSink.ForInternalDiagnostics(Log, InternalDiagnosticMessages);

            using (AssemblyHelper.SubscribeResolveForAssembly(typeof(xunit), internalDiagnosticsMessageSink))
            {
                var reporter = GetReporter();
                if (reporter == null)
                {
                    return(false);
                }

                logger = new MSBuildLogger(Log);
                reporterMessageHandler = MessageSinkWithTypesAdapter.Wrap(reporter.CreateMessageHandler(logger));

                if (!NoLogo)
                {
                    var versionAttribute = typeof(xunit).GetTypeInfo().Assembly.GetCustomAttribute <AssemblyInformationalVersionAttribute>();
                    Log.LogMessage(MessageImportance.High, $"xUnit.net MSBuild Runner v{versionAttribute.InformationalVersion} ({environment})");
                }

                var project = new XunitProject();
                foreach (var assembly in Assemblies)
                {
                    var assemblyFileName = assembly.GetMetadata("FullPath");
                    var configFileName   = assembly.GetMetadata("ConfigFile");
                    if (configFileName != null && configFileName.Length == 0)
                    {
                        configFileName = null;
                    }

                    var projectAssembly = new XunitProjectAssembly {
                        AssemblyFilename = assemblyFileName, ConfigFilename = configFileName
                    };
                    if (shadowCopy.HasValue)
                    {
                        projectAssembly.Configuration.ShadowCopy = shadowCopy;
                    }

                    project.Add(projectAssembly);
                }

                if (WorkingFolder != null)
                {
                    Directory.SetCurrentDirectory(WorkingFolder);
                }

                var clockTime = Stopwatch.StartNew();

                if (!parallelizeAssemblies.HasValue)
                {
                    parallelizeAssemblies = project.All(assembly => assembly.Configuration.ParallelizeAssemblyOrDefault);
                }

                if (parallelizeAssemblies.GetValueOrDefault())
                {
                    var tasks   = project.Assemblies.Select(assembly => Task.Run(() => ExecuteAssembly(assembly, appDomains)));
                    var results = Task.WhenAll(tasks).GetAwaiter().GetResult();
                    foreach (var assemblyElement in results.Where(result => result != null))
                    {
                        assembliesElement.Add(assemblyElement);
                    }
                }
                else
                {
                    foreach (var assembly in project.Assemblies)
                    {
                        var assemblyElement = ExecuteAssembly(assembly, appDomains);
                        if (assemblyElement != null)
                        {
                            assembliesElement.Add(assemblyElement);
                        }
                    }
                }

                clockTime.Stop();

                if (assembliesElement != null)
                {
                    assembliesElement.Add(new XAttribute("timestamp", DateTime.Now.ToString(CultureInfo.InvariantCulture)));
                }

                if (completionMessages.Count > 0)
                {
                    reporterMessageHandler.OnMessage(new TestExecutionSummary(clockTime.Elapsed, completionMessages.OrderBy(kvp => kvp.Key).ToList()));
                }
            }

            Directory.SetCurrentDirectory(WorkingFolder ?? originalWorkingFolder);

            if (NeedsXml)
            {
                if (Xml != null)
                {
                    using (var xmlStream = new FileStream(Xml.GetMetadata("FullPath"), FileMode.OpenOrCreate, FileAccess.Write))
                        assembliesElement.Save(xmlStream);
                }

                if (XmlV1 != null)
                {
                    CrossPlatform.Transform(logger, "XmlV1", "xUnit1.xslt", assembliesElement, XmlV1);
                }

                if (Html != null)
                {
                    CrossPlatform.Transform(logger, "Html", "HTML.xslt", assembliesElement, Html);
                }

                if (NUnit != null)
                {
                    CrossPlatform.Transform(logger, "NUnit", "NUnitXml.xslt", assembliesElement, NUnit);
                }

                if (JUnit != null)
                {
                    CrossPlatform.Transform(logger, "JUnit", "JUnitXml.xslt", assembliesElement, JUnit);
                }
            }

            // ExitCode is set to 1 for test failures and -1 for Exceptions.
            return(ExitCode == 0 || (ExitCode == 1 && IgnoreFailures));
        }