/// <summary> /// Searches the passed Path for Plugins /// </summary> /// <param name="Path">Directory to search for Plugins in</param> public void Load(string Path, string pattern) { //First empty the collection, we're reloading them all mAvailablePlugins.Clear(); try { //Go through all the files in the plugin directory foreach (string fileOn in Directory.GetFiles(Path, pattern)) { FileInfo file = new FileInfo(fileOn); //Preliminary check, must be .dll if (file.Extension.Equals(".dll")) { //Add the 'plugin' this.AddPlugin(fileOn); } } } catch (Exception ex) { System.Reflection.ReflectionTypeLoadException e = ex as System.Reflection.ReflectionTypeLoadException; if (e != null) { foreach (Exception ee in e.LoaderExceptions) { Console.WriteLine(ee.Message); } } } }
public static void TraceException(System.Exception exception) { if (exception == null) { WriteLine("Exception is null"); return; } WriteLine("Unhandled exception : " + exception.GetType().FullName + "\n" + "Message : " + exception.Message + "\n" + "Stack Trace \n" + exception.StackTrace + "\n" + "Source : " + exception.Source + "\n" + "TargetSite : " + exception.TargetSite + "\n" ); if (exception.InnerException != null) { WriteLine("Inner Exception"); TraceException(exception.InnerException); } System.Reflection.ReflectionTypeLoadException tle = exception as System.Reflection.ReflectionTypeLoadException; System.Security.SecurityException se = exception as System.Security.SecurityException; if (tle != null) { WriteLine("Loader Exceptions"); foreach (Exception tlle in tle.LoaderExceptions) { WriteLine("Loader Exception:"); TraceException(tlle); } } else if (se != null) { WriteLine("Security Exception"); WriteLine("Action : " + se.Action); WriteLine("PermissionType : " + se.PermissionType); } StackTrace st = new StackTrace(true); WriteLine("Current Stack" + st.ToString()); WriteLine("\r\nAssemblies:"); foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies()) { WriteLine("Name : " + asm.FullName); try { WriteLine("\tPath:" + asm.Location); } catch { } } }
protected virtual void HandlePluginLoadReflectionException(PluginData data, ReflectionTypeLoadException ex) { String err = "Error creating plugin from dll \"" + data.dll + "\" due to a loader exception error was:\n"; foreach (Exception e in ex.LoaderExceptions) err += e.Message + "\n"; data.last_error = err; data.state = PluginData.PluginDataState.ERROR_LOADING; Utils.PluginLog(PluginManagerName(), err); }
Tuple<string, bool> HandleReflectionTypeLoadException(ReflectionTypeLoadException e, ReportExceptionEventArgs et) { Tuple<string, bool> handled = null; foreach (var error in e.LoaderExceptions) { if (handled == null || handled.Item1 == null) handled = InternalHandler(error, et, true); } return handled; }
public static void ThrowReflectionTypeLoadException(ReflectionTypeLoadException tLException) { var loaderMessages = new StringBuilder(); loaderMessages.AppendLine("While trying to load composable parts the following loader exceptions were found: "); foreach (var loaderException in tLException.LoaderExceptions) { loaderMessages.AppendLine(loaderException.Message); } throw new Exception(loaderMessages.ToString(), tLException); }
static string FormatLoaderExceptionMessage(Assembly assembly, ReflectionTypeLoadException e) { //http://stackoverflow.com/questions/7889228/how-to-prevent-reflectiontypeloadexception-when-calling-assembly-gettypes StringBuilder message = new StringBuilder(); message.AppendLine(string.Format("{0} assembly LoaderException messages:", assembly.FullName)); foreach (Exception loaderException in e.LoaderExceptions) { if (loaderException == null) continue; message.AppendLine(loaderException.Message); } return message.ToString(); }
private static string GetLoaderExceptions(ReflectionTypeLoadException exception) { var sb = new StringBuilder(); sb.AppendLine(exception.ToString()); foreach (var loaderException in exception.LoaderExceptions) { sb.AppendLine("- - - -").AppendLine(); sb.AppendLine(loaderException.ToString()); } return sb.ToString(); }
private static string niceMessage(Assembly assembly, ReflectionTypeLoadException exception) { var result = new StringBuilder(); result.Append("Failed to load "); result.Append(assembly.FullName); result.Append(". "); result.Append(exception.Message); //TODO: add detail return result.ToString(); }
public void ReflectionTypeLoadExceptionSupport() { FileNotFoundException ex1 = new FileNotFoundException(); OutOfMemoryException ex2 = new OutOfMemoryException(); ReflectionTypeLoadException wrapper = new ReflectionTypeLoadException(new Type[] { typeof(FakeRaygunClient), typeof(WrapperException) }, new Exception[] { ex1, ex2 }); RaygunErrorMessage message = RaygunErrorMessageBuilder.Build(wrapper); Assert.AreEqual(2, message.InnerErrors.Count()); Assert.AreEqual("System.IO.FileNotFoundException", message.InnerErrors[0].ClassName); Assert.AreEqual("System.OutOfMemoryException", message.InnerErrors[1].ClassName); Assert.IsTrue(message.InnerErrors[0].Data["Type"].ToString().Contains("FakeRaygunClient")); Assert.IsTrue(message.InnerErrors[1].Data["Type"].ToString().Contains("WrapperException")); }
public override void ShowException(ReflectionTypeLoadException ex) { var message = "ReflectionTypeLoadException:"; var types = ex.Types; message += Environment.NewLine + " -------------- "; message += Environment.NewLine + " Types : " + (types == null ? "<null>" : types.Length.ToString(CultureInfo.CurrentUICulture)); message = AddTypes(message, types); message += Environment.NewLine + " -------------- "; message = AddExceptions(message, ex.LoaderExceptions); _logger.Trace(message); }
private static string CreateMessage(Assembly loadedAssembly, ReflectionTypeLoadException ex) { StringBuilder builder = new StringBuilder(); builder.AppendFormat("Unable to load types from assembly {0}:", loadedAssembly.GetName()).Append(Environment.NewLine); builder.AppendFormat("Failed to load {0} of the {1} types defined in the assembly.", ex.LoaderExceptions.Length, ex.Types.Length).Append(Environment.NewLine); builder.Append("Exceptions: ").Append(Environment.NewLine); foreach (Exception exception in ex.LoaderExceptions) { TypeLoadException loaderException = exception as TypeLoadException; if (loaderException != null) { builder.AppendFormat("- Unable to load type: {0}", loaderException.TypeName).Append(Environment.NewLine); } builder.Append(" Exception: ").Append(exception.ToString()); } return builder.ToString(); }
public static void HandleReflectionTypeLoadException(ReflectionTypeLoadException rfex) { string loaderExceptionMessages = ""; //string msg = "********************* " + helperMessage + "*********************"; foreach (var t in rfex.LoaderExceptions) { loaderExceptionMessages += " - "; loaderExceptionMessages += t.Message; loaderExceptionMessages += Environment.NewLine; } string msg = @" ********************* ReflectionTypeLoadException ********************* ***** Begin Loader Exception Messages ***** {0} ***** End Loader Exception Messages ***** ".FormatWith(loaderExceptionMessages); Server.Trace(msg); }
private static void PrintTypeLoadError(ReflectionTypeLoadException exc) { if (exc == null) return; LogWriteLine("LoaderExceptions:"); foreach (var e in exc.LoaderExceptions) { LogWrite("-- "); LogWrite(e.GetType().FullName); LogWrite(": "); LogWriteLine(e.Message); var fileNotFoundException = e as FileNotFoundException; if (fileNotFoundException != null) { LogWriteLine("FUSION LOG:"); LogWriteLine(fileNotFoundException.FusionLog); } } }
public NetReflectorTypeLoadException(Assembly loadedAssembly, ReflectionTypeLoadException ex) : base(CreateMessage(loadedAssembly, ex)) { }
private static string BuildErrorMessage(ReflectionTypeLoadException exception) { var builder = new StringBuilder("One or more errors occurred while loading the selected plugin:"); builder.AppendLine(); builder.AppendLine(); foreach (Exception loaderException in exception.LoaderExceptions) { builder.AppendLine(loaderException.Message); } return builder.ToString(); }
internal static string FormatReflectionTypeLoadException(string fileName, ReflectionTypeLoadException e) { var sb = new StringBuilder(); sb.AppendLine(string.Format("Could not enumerate all types for '{0}'.", fileName)); if (!e.LoaderExceptions.Any()) { sb.AppendLine(string.Format("Exception message: {0}", e)); return sb.ToString(); } var nsbAssemblyName = typeof(AssemblyScanner).Assembly.GetName(); var nsbPublicKeyToken = BitConverter.ToString(nsbAssemblyName.GetPublicKeyToken()).Replace("-", "").ToLowerInvariant(); var displayBindingRedirects = false; var displayHeader = true; foreach (var ex in e.LoaderExceptions) { var loadException = ex as FileLoadException; if (loadException != null) { var assemblyName = new AssemblyName(loadException.FileName); var assemblyPublicKeyToken = BitConverter.ToString(assemblyName.GetPublicKeyToken()).Replace("-", "").ToLowerInvariant(); if (nsbAssemblyName.Name == assemblyName.Name && nsbAssemblyName.CultureInfo.ToString() == assemblyName.CultureInfo.ToString() && nsbPublicKeyToken == assemblyPublicKeyToken) { displayBindingRedirects = true; } } else { if (displayHeader) { sb.AppendLine("Assembly scanner errors:"); displayHeader = false; } sb.AppendLine(ex.ToString()); } } if (displayBindingRedirects) { sb.AppendLine(); sb.AppendLine("It looks like you may be missing binding redirects in your config file, try to add the following binding redirects:"); const string bindingRedirects = @"<runtime> <assemblyBinding xmlns=""urn:schemas-microsoft-com:asm.v1""> <dependentAssembly> <assemblyIdentity name=""NServiceBus.Core"" publicKeyToken=""9fc386479f8a226c"" culture=""neutral"" /> <bindingRedirect oldVersion=""0.0.0.0-{0}"" newVersion=""{0}"" /> </dependentAssembly> <dependentAssembly> <assemblyIdentity name=""NServiceBus"" publicKeyToken=""9fc386479f8a226c"" culture=""neutral"" /> <bindingRedirect oldVersion=""0.0.0.0-{0}"" newVersion=""{0}"" /> </dependentAssembly> </assemblyBinding> </runtime>"; sb.AppendFormat(bindingRedirects, nsbAssemblyName.Version.ToString(4)); sb.AppendLine(); } return sb.ToString(); }
public LoadingAssemblyTypesEventArgs(Assembly assemblyFile, System.Reflection.ReflectionTypeLoadException exception) { AssemblyFile = assemblyFile; Exception = exception; }
private static bool InterceptReflectionTypeLoadException(ReflectionTypeLoadException outerException, out IEnumerable<string> complaints) { var badFiles = new Dictionary<string, string>(); foreach (var exception in outerException.LoaderExceptions) { var fileNotFound = exception as FileNotFoundException; var fileLoadError = exception as FileLoadException; string fileName = null; if (fileNotFound != null) { fileName = fileNotFound.FileName; } else if (fileLoadError != null) { fileName = fileLoadError.FileName; } if (fileName != null) { if (badFiles.ContainsKey(fileName)) { // Don't overright first entry for this file, because it probably contains best error } else { badFiles.Add(fileName, exception.Message); } } else { // we haven't anticipated this specific exception, so rethrow. complaints = null; return false; } } // experience shows that dependency errors in ReflectionTypeLoadExceptions tend to be redundant. // here, we ensure that each missing dependency is reported only once. complaints = badFiles.Select( (fileName, msg) => String.Format("An assembly dependency {0} could not be loaded: {1}", fileName, msg)).ToArray(); // exception was anticipated. return true; }
public UnableToGetTypesException(ReflectionTypeLoadException rtle) : base(rtle.Message) { loaderMessages = new string[rtle.LoaderExceptions.Length]; for (int i = 0; i < rtle.LoaderExceptions.Length; i++) { loaderMessages[i] = rtle.LoaderExceptions[i].Message; } }
public void VerifyNetReflectorTypeLoadExceptionMessage() { ReflectionTypeLoadException innerException = new ReflectionTypeLoadException(new Type[] {typeof (TestClass), null}, new Exception[] {new TypeLoadException("Failed to load TestSubClass")}); Assembly assembly = Assembly.GetCallingAssembly(); NetReflectorTypeLoadException exception = new NetReflectorTypeLoadException(assembly, innerException); AssertContains(assembly.GetName().ToString(), exception.Message); AssertContains("Failed to load 1 of the 2 types defined in the assembly.", exception.Message); AssertContains("Failed to load TestSubClass", exception.Message); }
internal static string FormatReflectionTypeLoadException(string fileName, ReflectionTypeLoadException e) { var sb = new StringBuilder(); sb.AppendLine(string.Format("Could not enumerate all types for '{0}'. Exception message: {1}.", fileName, e)); if (!e.LoaderExceptions.Any()) { return sb.ToString(); } sb.AppendLine("Scanned type errors:"); foreach (var ex in e.LoaderExceptions) { sb.AppendLine(ex.ToString()); } return sb.ToString(); }
private static void DumpReflectionTypeLoadException(ReflectionTypeLoadException loadException, StringBuilder sb) { if (loadException != null) { sb.AppendLine("LoaderExceptions property value:"); foreach (var loaderException in loadException.LoaderExceptions) { sb.AppendFormat("[{0} : {1}]", loaderException.GetType().FullName, loaderException.Message).AppendLine(); } sb.AppendLine("End of Loader Exceptions"); } }
public void Formatting3_Exception_formatting_is_very_descriptive_by_default() { Log.EntryPosted += (sender, e) => Console.WriteLine(e.LogEntry.ToLogString()); var dataException = new DataException("oops!"); dataException.Data["why?"] = "because"; var outerException = new ReflectionTypeLoadException(new[] { GetType() }, new[] { dataException }); try { throw outerException; } catch (Exception ex) { Log.Write(() => ex); } }
private void DisplayLoaderExceptionsOnConsole(ReflectionTypeLoadException e) { foreach (var loaderException in e.LoaderExceptions) { Console.WriteLine(loaderException.ToString()); } }
internal static string FormatReflectionTypeLoadException(string fileName, ReflectionTypeLoadException e) { var sb = new StringBuilder(); sb.AppendLine(string.Format("Could not enumerate all types for '{0}'.", fileName)); if (!e.LoaderExceptions.Any()) { sb.AppendLine(string.Format("Exception message: {0}", e)); return sb.ToString(); } var nsbAssemblyName = typeof(AssemblyScanner).Assembly.GetName(); var nsbPublicKeyToken = BitConverter.ToString(nsbAssemblyName.GetPublicKeyToken()).Replace("-", "").ToLowerInvariant(); var displayBindingRedirects = false; var files = new List<string>(); var sbFileLoadException = new StringBuilder(); var sbGenericException = new StringBuilder(); foreach (var ex in e.LoaderExceptions) { var loadException = ex as FileLoadException; if (loadException != null) { var assemblyName = new AssemblyName(loadException.FileName); var assemblyPublicKeyToken = BitConverter.ToString(assemblyName.GetPublicKeyToken()).Replace("-", "").ToLowerInvariant(); if (nsbAssemblyName.Name == assemblyName.Name && nsbAssemblyName.CultureInfo.ToString() == assemblyName.CultureInfo.ToString() && nsbPublicKeyToken == assemblyPublicKeyToken) { displayBindingRedirects = true; continue; } if (!files.Contains(loadException.FileName)) { files.Add(loadException.FileName); sbFileLoadException.AppendLine(loadException.FileName); } continue; } sbGenericException.AppendLine(ex.ToString()); } if (sbGenericException.ToString().Length > 0) { sb.AppendLine("Exceptions:"); sb.AppendLine(sbGenericException.ToString()); } if (sbFileLoadException.ToString().Length > 0) { sb.AppendLine("It looks like you may be missing binding redirects in your config file for the following assemblies:"); sb.Append(sbFileLoadException); sb.AppendLine("For more information see http://msdn.microsoft.com/en-us/library/7wd6ex19(v=vs.100).aspx"); } if (displayBindingRedirects) { sb.AppendLine(); sb.AppendLine("Try to add the following binding redirects to your config file:"); const string bindingRedirects = @"<runtime> <assemblyBinding xmlns=""urn:schemas-microsoft-com:asm.v1""> <dependentAssembly> <assemblyIdentity name=""NServiceBus.Core"" publicKeyToken=""9fc386479f8a226c"" culture=""neutral"" /> <bindingRedirect oldVersion=""0.0.0.0-{0}"" newVersion=""{0}"" /> </dependentAssembly> <dependentAssembly> <assemblyIdentity name=""NServiceBus"" publicKeyToken=""9fc386479f8a226c"" culture=""neutral"" /> <bindingRedirect oldVersion=""0.0.0.0-{0}"" newVersion=""{0}"" /> </dependentAssembly> </assemblyBinding> </runtime>"; sb.AppendFormat(bindingRedirects, nsbAssemblyName.Version.ToString(4)); sb.AppendLine(); } return sb.ToString(); }
public void StripReflectionTypeLoadException() { _client.AddWrapperExceptions(typeof(ReflectionTypeLoadException)); FileNotFoundException ex1 = new FileNotFoundException(); FileNotFoundException ex2 = new FileNotFoundException(); ReflectionTypeLoadException wrapper = new ReflectionTypeLoadException(new Type[] { typeof(FakeRaygunClient), typeof(WrapperException) }, new Exception[] { ex1, ex2 }); List<Exception> exceptions = _client.ExposeStripWrapperExceptions(wrapper).ToList(); Assert.AreEqual(2, exceptions.Count); Assert.Contains(ex1, exceptions); Assert.Contains(ex2, exceptions); Assert.IsTrue(ex1.Data["Type"].ToString().Contains("FakeRaygunClient")); Assert.IsTrue(ex2.Data["Type"].ToString().Contains("WrapperException")); }
private static void PrintReflectionTypeLoadException(ReflectionTypeLoadException e) { LogWriteLine("---- LoaderExceptions:"); var count = 1; foreach (var ex in e.LoaderExceptions) { LogWriteLine("---- LoaderException #" + count++); LogWrite(ex.GetType().Name); LogWrite(": "); LogWriteLine(ex.Message); LogWriteLine(ex.StackTrace); } LogWriteLine("---- LoaderException Types:"); foreach (var type in e.Types) { LogWriteLine(type); } }
public LoadPluginException(Assembly assembly, ReflectionTypeLoadException exception) : base(niceMessage(assembly, exception), exception) { }
private static string GetReflectionTypeLoadExceptionMessage(ReflectionTypeLoadException exception) { StringBuilder builder = new StringBuilder(); // lookup table for duplicate messages List<string> messages = new List<string>(); builder.AppendLine(exception.Message); builder.AppendLine(Properties.Resources.LoaderExceptionMessages); foreach (Exception error in exception.LoaderExceptions) { if (!messages.Contains(error.Message)) { builder.AppendLine(error.Message); messages.Add(error.Message); } } builder.AppendLine(Properties.Resources.LoaderExceptionTypeMessages); foreach (Type type in exception.Types) { if (type != null && !messages.Contains(type.FullName)) { builder.AppendLine(type.FullName); messages.Add(type.FullName); } } return builder.ToString(); }
public DefaultHttpControllerTypeResolverTracerTest() { ExpectedTypes = new List<Type> { typeof(ValidController), typeof(UsersRpcController), typeof(UsersController), }; Type[] fine1Types = new Type[] { typeof(DefaultHttpControllerTypeResolverTracerTest), null, typeof(ValidController), }; Type[] poorTypes = new Type[] { typeof(string), null, typeof(Action), null, typeof(UsersRpcController), }; Type[] fine2Types = new Type[] { typeof(DefaultHttpControllerTypeResolver), null, typeof(DefaultHttpControllerTypeResolverTracer), null, typeof(UsersController) }; Exception worseException = new Exception(ExceptionMessage); Exception poorException = new ReflectionTypeLoadException(poorTypes, new Exception[] { worseException }); ExpectedTraces = new List<TraceRecord> { new TraceRecord(null, TraceCategories.ControllersCategory, TraceLevel.Debug) { Kind = TraceKind.Begin, Operator = "DefaultHttpControllerTypeResolverProxy", // Moq type name Operation = "GetControllerTypes", }, new TraceRecord(null, TraceCategories.ControllersCategory, TraceLevel.Warn) { Kind = TraceKind.Trace, Exception = poorException, Message = "Exception thrown while getting types from 'PoorAssembly'.", }, new TraceRecord(null, TraceCategories.ControllersCategory, TraceLevel.Warn) { Kind = TraceKind.Trace, Exception = worseException, Message = "Exception thrown while getting types from 'WorseAssembly'.", }, new TraceRecord(null, TraceCategories.ControllersCategory, TraceLevel.Debug) { Kind = TraceKind.End, Operator = "DefaultHttpControllerTypeResolverProxy", Operation = "GetControllerTypes", }, }; Mock<MockableAssembly> fine1Assembly = new Mock<MockableAssembly>(MockBehavior.Strict); fine1Assembly.Setup(assembly => assembly.GetTypes()).Returns(fine1Types); fine1Assembly.SetupGet(assembly => assembly.IsDynamic).Returns(false); Exception[] exceptions = new Exception[] { new Exception(ExceptionMessage), }; Mock<MockableAssembly> poorAssembly = new Mock<MockableAssembly>(MockBehavior.Strict); poorAssembly.Setup(assembly => assembly.GetTypes()).Throws(poorException); poorAssembly.SetupGet(assembly => assembly.IsDynamic).Returns(false); poorAssembly.SetupGet(assembly => assembly.FullName).Returns("PoorAssembly"); Mock<MockableAssembly> worseAssembly = new Mock<MockableAssembly>(MockBehavior.Strict); worseAssembly.Setup(assembly => assembly.GetTypes()).Throws(worseException); worseAssembly.SetupGet(assembly => assembly.IsDynamic).Returns(false); worseAssembly.SetupGet(assembly => assembly.FullName).Returns("WorseAssembly"); Mock<MockableAssembly> fine2Assembly = new Mock<MockableAssembly>(MockBehavior.Strict); fine2Assembly.Setup(assembly => assembly.GetTypes()).Returns(fine2Types); fine2Assembly.SetupGet(assembly => assembly.IsDynamic).Returns(false); Mock<MockableAssembly> dynamicAssembly = new Mock<MockableAssembly>(MockBehavior.Strict); dynamicAssembly.SetupGet(assembly => assembly.IsDynamic).Returns(true); Assemblies = new Mock<MockableAssembly>[] { fine1Assembly, poorAssembly, worseAssembly, fine2Assembly, dynamicAssembly, }; AssembliesResolver = new Mock<IAssembliesResolver>(MockBehavior.Strict); AssembliesResolver.Setup(resolver => resolver.GetAssemblies()).Returns( Assemblies.Select(assembly => (Assembly)assembly.Object).AsCollection()); HttpControllerTypeResolver = new Mock<DefaultHttpControllerTypeResolver>() { CallBase = true, }; }
protected override void HandlePluginLoadReflectionException(PluginData data, ReflectionTypeLoadException ex) { base.HandlePluginLoadReflectionException(data, ex); active_plugin = null; }
public void Exceptions_always_get_properties_formatters() { var exception = new ReflectionTypeLoadException( new[] { typeof (FileStyleUriParser), typeof (AssemblyKeyFileAttribute) }, new Exception[] { new EventLogInvalidDataException() }); var formatter = new FormatterSet(); var message = formatter.Format(exception); Assert.That(message, Contains.Substring("ReflectionTypeLoadException")); Assert.That(message, Contains.Substring("FileStyleUriParser")); Assert.That(message, Contains.Substring("AssemblyKeyFileAttribute")); Assert.That(message, Contains.Substring("EventLogInvalidDataException")); }