Exemplo n.º 1
0
        void ReportReflectionException(IProgressStatus monitor, Exception ex, AddinDescription config, AddinScanResult scanResult)
        {
            scanResult.AddFileToWithFailure(config.AddinFile);
            monitor.ReportWarning("[" + config.AddinId + "] Could not load some add-in assemblies: " + ex.Message);
            if (monitor.LogLevel <= 1)
            {
                return;
            }

            ReflectionTypeLoadException rex = ex as ReflectionTypeLoadException;

            if (rex != null)
            {
                foreach (Exception e in rex.LoaderExceptions)
                {
                    monitor.Log("Load exception: " + e);
                }
            }
        }
Exemplo n.º 2
0
        void ReportReflectionException(IProgressStatus monitor, Exception ex, AddinDescription config, AddinScanResult scanResult)
        {
            scanResult.AddFileToWithFailure (config.AddinFile);
            monitor.ReportWarning ("[" + config.AddinId + "] Could not load some add-in assemblies: " + ex.Message);
            if (monitor.LogLevel <= 1)
                return;

            ReflectionTypeLoadException rex = ex as ReflectionTypeLoadException;
            if (rex != null) {
                foreach (Exception e in rex.LoaderExceptions)
                    monitor.Log ("Load exception: " + e);
            }
        }
        bool ScanDescription(IProgressStatus monitor, AddinDescription config, Assembly rootAssembly, AddinScanResult scanResult)
        {
            // First of all scan the main module

            ArrayList assemblies           = new ArrayList();
            ArrayList hostExtensionClasses = new ArrayList();

            try {
                foreach (string s in config.MainModule.Assemblies)
                {
                    string   asmFile = Path.Combine(config.BasePath, s);
                    Assembly asm     = Util.LoadAssemblyForReflection(asmFile);
                    assemblies.Add(asm);
                }

                foreach (Assembly asm in assemblies)
                {
                    ScanAssemblyAddinHeaders(config, asm, scanResult);
                }

                // The add-in id and version must be already assigned at this point

                // Clean host data from the index. New data will be added.
                if (scanResult.HostIndex != null)
                {
                    scanResult.HostIndex.RemoveHostData(config.AddinId, config.AddinFile);
                }

                foreach (Assembly asm in assemblies)
                {
                    ScanAssemblyContents(config, asm, hostExtensionClasses, scanResult);
                }

                if (config.IsRoot && scanResult.HostIndex != null)
                {
                    // If the add-in is a root, register its assemblies
                    foreach (Assembly asm in assemblies)
                    {
                        string asmFile = new Uri(asm.CodeBase).LocalPath;
                        scanResult.HostIndex.RegisterAssembly(asmFile, config.AddinId, config.AddinFile);
                    }
                }
            } catch (Exception ex) {
                if (monitor.VerboseLog)
                {
                    monitor.Log("Could not load some add-in assemblies: " + ex.Message);
                }
                scanResult.AddFileToWithFailure(config.AddinFile);
                return(false);
            }

            foreach (Type t in hostExtensionClasses)
            {
                RegisterHostTypeNode(config, t, assemblies);
            }

            // Extension node types may have child nodes declared as attributes. Find them.

            Hashtable internalNodeSets = new Hashtable();

            foreach (ExtensionNodeSet eset in config.ExtensionNodeSets)
            {
                ScanNodeSet(config, eset, assemblies, internalNodeSets);
            }

            foreach (ExtensionPoint ep in config.ExtensionPoints)
            {
                ScanNodeSet(config, ep.NodeSet, assemblies, internalNodeSets);
            }

            // Now scan all modules

            if (!config.IsRoot)
            {
                foreach (ModuleDescription mod in config.OptionalModules)
                {
                    try {
                        assemblies.Clear();
                        foreach (string s in mod.Assemblies)
                        {
                            string   asmFile = Path.Combine(config.BasePath, s);
                            Assembly asm     = Util.LoadAssemblyForReflection(asmFile);
                            assemblies.Add(asm);
                        }
                        foreach (Assembly asm in assemblies)
                        {
                            ScanAssemblyContents(config, asm, null, scanResult);
                        }

                        if (config.IsRoot && scanResult.HostIndex != null)
                        {
                            // If the add-in is a root, register its assemblies
                            foreach (Assembly asm in assemblies)
                            {
                                string asmFile = new Uri(asm.CodeBase).LocalPath;
                                scanResult.HostIndex.RegisterAssembly(asmFile, config.AddinId, config.AddinFile);
                            }
                        }
                    } catch (Exception ex) {
                        if (monitor.VerboseLog)
                        {
                            monitor.Log("Could not load some add-in assemblies: " + ex.Message);
                        }
                        scanResult.AddFileToWithFailure(config.AddinFile);
                    }
                }
            }

            return(true);
        }
		bool ScanDescription (IProgressStatus monitor, AddinDescription config, Assembly rootAssembly, AddinScanResult scanResult)
		{
			// First of all scan the main module
			
			ArrayList assemblies = new ArrayList ();
			ArrayList hostExtensionClasses = new ArrayList ();
			
			try {
				foreach (string s in config.MainModule.Assemblies) {
					string asmFile = Path.Combine (config.BasePath, s);
					Assembly asm = Util.LoadAssemblyForReflection (asmFile);
					assemblies.Add (asm);
				}
				
				foreach (Assembly asm in assemblies)
					ScanAssemblyAddinHeaders (config, asm, scanResult);
				
				// The add-in id and version must be already assigned at this point
				
				// Clean host data from the index. New data will be added.
				if (scanResult.HostIndex != null)
					scanResult.HostIndex.RemoveHostData (config.AddinId, config.AddinFile);

				foreach (Assembly asm in assemblies)
					ScanAssemblyContents (config, asm, hostExtensionClasses, scanResult);
				
				if (config.IsRoot && scanResult.HostIndex != null) {
					// If the add-in is a root, register its assemblies
					foreach (Assembly asm in assemblies) {
						string asmFile = new Uri (asm.CodeBase).LocalPath;
						scanResult.HostIndex.RegisterAssembly (asmFile, config.AddinId, config.AddinFile);
					}
				}
				
			} catch (Exception ex) {
				if (monitor.VerboseLog)
					monitor.Log ("Could not load some add-in assemblies: " + ex.Message);
				scanResult.AddFileToWithFailure (config.AddinFile);
				return false;
			}
			
			foreach (Type t in hostExtensionClasses) {
				RegisterHostTypeNode (config, t, assemblies);
			}
			
			// Extension node types may have child nodes declared as attributes. Find them.
			
			Hashtable internalNodeSets = new Hashtable ();
			
			foreach (ExtensionNodeSet eset in config.ExtensionNodeSets)
				ScanNodeSet (config, eset, assemblies, internalNodeSets);
			
			foreach (ExtensionPoint ep in config.ExtensionPoints) {
				ScanNodeSet (config, ep.NodeSet, assemblies, internalNodeSets);
			}
		
			// Now scan all modules
			
			if (!config.IsRoot) {
				foreach (ModuleDescription mod in config.OptionalModules) {
					try {
						assemblies.Clear ();
						foreach (string s in mod.Assemblies) {
							string asmFile = Path.Combine (config.BasePath, s);
							Assembly asm = Util.LoadAssemblyForReflection (asmFile);
							assemblies.Add (asm);
						}
						foreach (Assembly asm in assemblies)
							ScanAssemblyContents (config, asm, null, scanResult);
				
						if (config.IsRoot && scanResult.HostIndex != null) {
							// If the add-in is a root, register its assemblies
							foreach (Assembly asm in assemblies) {
								string asmFile = new Uri (asm.CodeBase).LocalPath;
								scanResult.HostIndex.RegisterAssembly (asmFile, config.AddinId, config.AddinFile);
							}
						}
						
					} catch (Exception ex) {
						if (monitor.VerboseLog)
							monitor.Log ("Could not load some add-in assemblies: " + ex.Message);
						scanResult.AddFileToWithFailure (config.AddinFile);
					}
				}
			}
			
			return true;
		}