/// <summary> /// Initiate an instance of runspace configuration entry. /// </summary> /// <param name="name">Name for the runspace configuration entry</param> /// <param name="psSnapin">The name of the PSSnapin the entry comes from.</param> /// <!-- /// This is meant to be called by derived class only. It doesn't make sense to /// directly create an instance of this class. /// --> internal RunspaceConfigurationEntry(string name, PSSnapInInfo psSnapin) { if (String.IsNullOrEmpty(name) || String.IsNullOrEmpty(name.Trim())) { throw PSTraceSource.NewArgumentNullException("name"); } Name = name.Trim(); if (psSnapin == null) { throw PSTraceSource.NewArgumentException("psSnapin"); } PSSnapIn = psSnapin; }
/// <summary> /// Adds a mshsnapin specified by <paramref name="mshSnapInID"/> to the current list of /// mshsnapins. If the mshsnapin is successfully added, IsDirty property is set to true. /// </summary> /// <param name="mshSnapInID">ID of the mshsnapin which needs to be added.</param> /// <returns>A <see cref="PSSnapInInfo"/> object corresponding to mshSnapInID.</returns> /// <remarks>PSSnapIn information must be present in the registry for this call to succeed.</remarks> /// <exception cref="PSArgumentNullException"> /// mshSnapInID is empty or null. /// </exception> /// <exception cref="PSArgumentException"> /// PSSnapIn is already loaded. /// No PSSnapIn with given id found. /// PSSnapIn cannot be loaded. /// </exception> /// <exception cref="System.Security.SecurityException"> /// Caller doesn't have permission to read keys. /// </exception> internal PSSnapInInfo AddPSSnapIn(string mshSnapInID) { if (string.IsNullOrEmpty(mshSnapInID)) { PSTraceSource.NewArgumentNullException("mshSnapInID"); } // Check whether the mshsnapin is already present in defaultmshsnapins/externalMshSnapins if (IsDefaultPSSnapIn(mshSnapInID, _defaultPSSnapIns)) { s_mshsnapinTracer.TraceError("MshSnapin {0} can't be added since it is a default mshsnapin", mshSnapInID); throw PSTraceSource.NewArgumentException("mshSnapInID", ConsoleInfoErrorStrings.CannotLoadDefault); } if (IsActiveExternalPSSnapIn(mshSnapInID)) { s_mshsnapinTracer.TraceError("MshSnapin {0} is already loaded.", mshSnapInID); throw PSTraceSource.NewArgumentException("mshSnapInID", ConsoleInfoErrorStrings.PSSnapInAlreadyExists, mshSnapInID); } // Check whether the mshsnapin is present in the registry. PSSnapInInfo newPSSnapIn = PSSnapInReader.Read(this.MajorVersion, mshSnapInID); if (!Utils.IsPSVersionSupported(newPSSnapIn.PSVersion.ToString())) { s_mshsnapinTracer.TraceError("MshSnapin {0} and current monad engine's versions don't match.", mshSnapInID); throw PSTraceSource.NewArgumentException("mshSnapInID", ConsoleInfoErrorStrings.AddPSSnapInBadMonadVersion, newPSSnapIn.PSVersion.ToString(), PSVersion.ToString()); } // new mshsnapin will never be null //if this is a valid new mshsnapin,add this to external mshsnapins _externalPSSnapIns.Add(newPSSnapIn); s_mshsnapinTracer.WriteLine("MshSnapin {0} successfully added to consoleinfo list.", mshSnapInID); //Set IsDirty to true IsDirty = true; return(newPSSnapIn); }
private void UnloadPSSnapIn(PSSnapInInfo mshsnapinInfo, out PSSnapInException warning) { warning = null; if (mshsnapinInfo != null) { string str; this.Cmdlets.RemovePSSnapIn(mshsnapinInfo.Name); this.Providers.RemovePSSnapIn(mshsnapinInfo.Name); this.Assemblies.RemovePSSnapIn(mshsnapinInfo.Name); this.Types.RemovePSSnapIn(mshsnapinInfo.Name); this.Formats.RemovePSSnapIn(mshsnapinInfo.Name); this.UpdateAll(out str); if (!string.IsNullOrEmpty(str)) { _mshsnapinTracer.TraceWarning(str, new object[0]); warning = new PSSnapInException(mshsnapinInfo.Name, str, true); } } }
/// <summary> /// Removes a mshsnapin specified by <paramref name="mshSnapInID"/> from the current /// list. /// </summary> /// <param name="mshSnapInID">ID of the mshsnapin which needs to be removed</param> /// <returns>PSSnapInInfo object for the mshsnapin that is removed.</returns> /// <remarks>MshSnapin is removed only from the console file. Registry entry /// is not touched.</remarks> /// <exception cref="PSArgumentNullException"> /// mshSnapInID is null. /// </exception> /// <exception cref="PSArgumentException"> /// 1. mshSnapInID is either a default mshsnapin or not loaded. /// 2. mshSnapInId is not valid. /// </exception> internal PSSnapInInfo RemovePSSnapIn(string mshSnapInID) { if (string.IsNullOrEmpty(mshSnapInID)) { PSTraceSource.NewArgumentNullException("mshSnapInID"); } // Monad has specific restrictions on the mshsnapinid like // mshsnapinid should be A-Za-z0-9.-_ etc. PSSnapInInfo.VerifyPSSnapInFormatThrowIfError(mshSnapInID); PSSnapInInfo removedPSSnapIn = null; // Check external mshsnapins foreach (PSSnapInInfo mshSnapIn in _externalPSSnapIns) { if (string.Equals(mshSnapInID, mshSnapIn.Name, System.StringComparison.OrdinalIgnoreCase)) { // We found the mshsnapin..remove from the list and break removedPSSnapIn = mshSnapIn; _externalPSSnapIns.Remove(mshSnapIn); // The state of console file is changing..so set // dirty flag. IsDirty = true; break; } } if (removedPSSnapIn == null) { if (IsDefaultPSSnapIn(mshSnapInID, _defaultPSSnapIns)) { s_mshsnapinTracer.WriteLine("MshSnapin {0} can't be removed since it is a default mshsnapin.", mshSnapInID); throw PSTraceSource.NewArgumentException("mshSnapInID", ConsoleInfoErrorStrings.CannotRemoveDefault, mshSnapInID); } throw PSTraceSource.NewArgumentException("mshSnapInID", ConsoleInfoErrorStrings.CannotRemovePSSnapIn, mshSnapInID); } return(removedPSSnapIn); }
/// <exception cref="PSArgumentNullException"> /// mshSnapInID is null. /// </exception> /// <exception cref="PSArgumentException"> /// mshSnapInID is either a default mshsnapin or not loaded. /// </exception> internal override PSSnapInInfo DoRemovePSSnapIn(string name, out PSSnapInException warning) { warning = null; if (_consoleInfo == null) { return(null); } s_mshsnapinTracer.WriteLine("Removing mshsnapin {0}", name); PSSnapInInfo mshsnapinInfo = _consoleInfo.RemovePSSnapIn(name); UnloadPSSnapIn(mshsnapinInfo, out warning); s_mshsnapinTracer.WriteLine("MshSnapin {0} removed", name); return(mshsnapinInfo); }
internal ProviderConfigurationEntry( string name, Type implementingType, string helpFileName, PSSnapInInfo psSnapinInfo) : base(name, psSnapinInfo) { using (ProviderConfigurationEntry.tracer.TraceConstructor((object)this)) { this._type = implementingType != null ? implementingType : throw ProviderConfigurationEntry.tracer.NewArgumentNullException(nameof(implementingType)); if (!string.IsNullOrEmpty(helpFileName)) { this._helpFileName = helpFileName.Trim(); } else { this._helpFileName = helpFileName; } } }
internal Collection <PSSnapInInfo> GetPSSnapIn( string pattern, bool searchRegistry) { bool flag = WildcardPattern.ContainsWildcardCharacters(pattern); if (!flag) { PSSnapInInfo.VerifyPSSnapInFormatThrowIfError(pattern); } Collection <PSSnapInInfo> collection1 = searchRegistry ? PSSnapInReader.ReadAll() : this.PSSnapIns; Collection <PSSnapInInfo> collection2 = new Collection <PSSnapInInfo>(); if (collection1 == null) { return(collection2); } if (!flag) { foreach (PSSnapInInfo psSnapInInfo in collection1) { if (string.Equals(psSnapInInfo.Name, pattern, StringComparison.OrdinalIgnoreCase)) { collection2.Add(psSnapInInfo); } } } else { WildcardPattern wildcardPattern = new WildcardPattern(pattern, WildcardOptions.IgnoreCase); foreach (PSSnapInInfo psSnapInInfo in collection1) { if (wildcardPattern.IsMatch(psSnapInInfo.Name)) { collection2.Add(psSnapInInfo); } } } return(collection2); }
private static bool RunScript(string cmd) { // create Powershell runspace try { RunspaceConfiguration rsConfig = RunspaceConfiguration.Create(); PSSnapInException snapInException = null; PSSnapInInfo info = rsConfig.AddPSSnapIn("Microsoft.Exchange.Management.PowerShell.E2010", out snapInException); Runspace myRunSpace = RunspaceFactory.CreateRunspace(rsConfig); myRunSpace.Open(); Pipeline pipeLine = myRunSpace.CreatePipeline(); Command myCommand = new Command(cmd, true); pipeLine.Commands.Add(myCommand); Collection <PSObject> commandResults = pipeLine.Invoke(); foreach (PSObject obj in commandResults) { Console.WriteLine(obj.ToString()); } return(true); } catch (Exception ex) { return(false); } }
private void UnloadPSSnapIn(PSSnapInInfo mshsnapinInfo, out PSSnapInException warning) { warning = null; if (mshsnapinInfo != null) { this.Cmdlets.RemovePSSnapIn(mshsnapinInfo.Name); this.Providers.RemovePSSnapIn(mshsnapinInfo.Name); this.Assemblies.RemovePSSnapIn(mshsnapinInfo.Name); this.Types.RemovePSSnapIn(mshsnapinInfo.Name); this.Formats.RemovePSSnapIn(mshsnapinInfo.Name); string errors; UpdateAll(out errors); if (!String.IsNullOrEmpty(errors)) { s_mshsnapinTracer.TraceWarning(errors); warning = new PSSnapInException(mshsnapinInfo.Name, errors, true); } } }
private void LoadPSSnapIn(PSSnapInInfo mshsnapinInfo) { if (mshsnapinInfo != null) { if (!string.IsNullOrEmpty(mshsnapinInfo.CustomPSSnapInType)) { this.LoadCustomPSSnapIn(mshsnapinInfo); } else { Assembly assembly = null; _mshsnapinTracer.WriteLine("Loading assembly for mshsnapin {0}", new object[] { mshsnapinInfo.Name }); assembly = this.LoadMshSnapinAssembly(mshsnapinInfo); if (assembly == null) { _mshsnapinTracer.TraceError("Loading assembly for mshsnapin {0} failed", new object[] { mshsnapinInfo.Name }); } else { _mshsnapinTracer.WriteLine("Loading assembly for mshsnapin {0} succeeded", new object[] { mshsnapinInfo.Name }); this.AnalyzeMshSnapinAssembly(assembly, mshsnapinInfo); foreach (string str in mshsnapinInfo.Types) { string name = Path.Combine(mshsnapinInfo.ApplicationBase, str); TypeConfigurationEntry entry = new TypeConfigurationEntry(name, name, mshsnapinInfo); this.Types.AddBuiltInItem(entry); } foreach (string str3 in mshsnapinInfo.Formats) { string str4 = Path.Combine(mshsnapinInfo.ApplicationBase, str3); FormatConfigurationEntry entry2 = new FormatConfigurationEntry(str4, str4, mshsnapinInfo); this.Formats.AddBuiltInItem(entry2); } AssemblyConfigurationEntry item = new AssemblyConfigurationEntry(mshsnapinInfo.AssemblyName, mshsnapinInfo.AbsoluteModulePath, mshsnapinInfo); this.Assemblies.AddBuiltInItem(item); } } } }
/// <summary> /// Removes all cmdlets of a specific PSSnapIn /// </summary> /// <param name="snapinInfo">Information about the PSSnapIn whose cmdlets should be removed</param> internal void RemoveCmdlets(PSSnapInInfo snapinInfo) { foreach (var pair in _cmdLets) { Collection <CmdletInfo> removables = new Collection <CmdletInfo>(); foreach (var cmdlet in pair.Value) { if (cmdlet.PSSnapIn == null) // not loaded with a snapin. e.g. with a module { continue; } if (cmdlet.PSSnapIn.Equals(snapinInfo)) { removables.Add(cmdlet); } } foreach (var rmCmdlet in removables) { pair.Value.Remove(rmCmdlet); } } }
public static string ExecPowerShellCommand(string sCommand, bool bRemoveEmptyLines) { if (runspace == null) { PSSnapInInfo info = null; PSSnapInException ex = null; bool error = false; try { runspace = RunspaceFactory.CreateRunspace(RunspaceConfiguration.Create()); runspace.Open(); foreach (string pssnapin in ExchangePsSnapin) { if (Execute("$(Get-PSSnapin -Registered | Select-String " + pssnapin + ") -ne $null", true).Trim() == "True") { info = runspace.RunspaceConfiguration.AddPSSnapIn(pssnapin, out ex); } } } catch (Exception) { error = true; } if (ex != null || info == null || error) { if (runspace != null) { runspace.Dispose(); runspace = null; } throw new ExchangeServerException("Couldn't initialize PowerShell runspace."); } } return(Execute(sCommand, bRemoveEmptyLines)); }
internal override PSSnapInInfo DoAddPSSnapIn(string name, out PSSnapInException warning) { warning = null; _mshsnapinTracer.WriteLine("Adding mshsnapin {0}", new object[] { name }); if (this._consoleInfo == null) { return(null); } PSSnapInInfo mshsnapinInfo = null; try { mshsnapinInfo = this._consoleInfo.AddPSSnapIn(name); } catch (PSArgumentException exception) { _mshsnapinTracer.TraceError(exception.Message, new object[0]); _mshsnapinTracer.WriteLine("Adding mshsnapin {0} failed.", new object[] { name }); throw; } catch (PSArgumentNullException exception2) { _mshsnapinTracer.TraceError(exception2.Message, new object[0]); _mshsnapinTracer.WriteLine("Adding mshsnapin {0} failed.", new object[] { name }); throw; } if (mshsnapinInfo == null) { return(null); } this.LoadPSSnapIn(mshsnapinInfo, out warning); if (warning != null) { _mshsnapinTracer.TraceWarning("There was a warning when loading mshsnapin {0}: {1}", new object[] { name, warning.Message }); } _mshsnapinTracer.WriteLine("MshSnapin {0} added", new object[] { name }); return(mshsnapinInfo); }
protected Collection <PSSnapInInfo> GetSnapIns(string pattern) { Collection <PSSnapInInfo> results; if (WildcardPattern.ContainsWildcardCharacters(pattern)) { results = ExecutionContext.SessionStateGlobal.GetPSSnapIns(new WildcardPattern(pattern)); } else //usual name { results = new Collection <PSSnapInInfo>(); PSSnapInInfo info = ExecutionContext.SessionStateGlobal.GetPSSnapIn(pattern); if (info != null) { results.Add(info); } } if (results.Count < 1) { throw new PSArgumentException(String.Format(NoSnapinsFoundFormat, pattern)); } return(results); }
private void LoadPSSnapIn(PSSnapInInfo mshsnapinInfo, out PSSnapInException warning) { string str; warning = null; try { this.LoadPSSnapIn(mshsnapinInfo); } catch (PSSnapInException) { if (!mshsnapinInfo.IsDefault) { this._consoleInfo.RemovePSSnapIn(mshsnapinInfo.Name); } throw; } this.UpdateAll(out str); if (!string.IsNullOrEmpty(str)) { _mshsnapinTracer.TraceWarning("There was a warning while loading mshsnapin {0}:{1}", new object[] { mshsnapinInfo.Name, str }); warning = new PSSnapInException(mshsnapinInfo.Name, str, true); } }
// TODO: separate providers from cmdlets internal Collection <CmdletInfo> LoadCmdletsFromPSSnapin(string strType, out Collection <SnapinProviderPair> providers) { Type snapinType = Type.GetType(strType, true); Assembly assembly = snapinType.Assembly; PSSnapIn snapin = Activator.CreateInstance(snapinType) as PSSnapIn; PSSnapInInfo snapinInfo = new PSSnapInInfo(snapin.Name, false, string.Empty, assembly.GetName().Name, string.Empty, new Version(1, 0), null, null, null, snapin.Description, snapin.Vendor); var snapinProviderPairs = from Type type in assembly.GetTypes() where !type.IsSubclassOf(typeof(Cmdlet)) where type.IsSubclassOf(typeof(CmdletProvider)) from CmdletProviderAttribute providerAttr in type.GetCustomAttributes(typeof(CmdletProviderAttribute), true) select new SnapinProviderPair { snapinInfo = snapinInfo, providerType = type, providerAttr = providerAttr }; providers = snapinProviderPairs.ToCollection(); return(LoadCmdletsFromAssembly(assembly, snapinInfo).ToCollection()); }
private void LoadPSSnapIn(PSSnapInInfo mshsnapinInfo, out PSSnapInException warning) { warning = null; try { LoadPSSnapIn(mshsnapinInfo); } catch (PSSnapInException) { if (!mshsnapinInfo.IsDefault) _consoleInfo.RemovePSSnapIn(mshsnapinInfo.Name); // exception during load mshsnapin are fatal. throw; } string errors; UpdateAll(out errors); if (!String.IsNullOrEmpty(errors)) { s_mshsnapinTracer.TraceWarning("There was a warning while loading mshsnapin {0}:{1}", mshsnapinInfo.Name, errors); warning = new PSSnapInException(mshsnapinInfo.Name, errors, true); } }
internal ProviderConfigurationEntry(string name, Type implementingType, string helpFileName, PSSnapInInfo psSnapinInfo) : base(name, psSnapinInfo) { ImplementingType = implementingType; HelpFileName = helpFileName; }
/// <summary> /// Initiate an instance for assembly configuration entry. /// </summary> /// <param name="name">Strong name of the assembly</param> /// <param name="fileName">Name of the assembly file</param> /// <param name="psSnapinInfo">PSSnapin information.</param> /// <exception cref="ArgumentException">when <paramref name="fileName"/> is null, empty or does not end in .ps1xml</exception> internal AssemblyConfigurationEntry(string name, string fileName, PSSnapInInfo psSnapinInfo) : base(name, psSnapinInfo) { if (String.IsNullOrEmpty(fileName) || String.IsNullOrEmpty(fileName.Trim())) { throw PSTraceSource.NewArgumentNullException("fileName"); } FileName = fileName.Trim(); }
protected InitialSessionStateEntry(string name) { this.name = name; this.psSnapIn = null; this.module = null; }
/// <summary> /// Initiate an instance for provider configuration entry. /// </summary> /// <param name="name">Name of the provider configuration entry</param> /// <param name="implementingType">Class that include implementation of the provider</param> /// <param name="helpFileName">Name of the help file that include help information for the provider</param> /// <param name="psSnapinInfo">PSSnapin from which provider comes from.</param> internal ProviderConfigurationEntry(string name, Type implementingType, string helpFileName, PSSnapInInfo psSnapinInfo) : base(name, psSnapinInfo) { if (implementingType == null) { throw PSTraceSource.NewArgumentNullException("implementingType"); } ImplementingType = implementingType; if (!String.IsNullOrEmpty(helpFileName)) { HelpFileName = helpFileName.Trim(); } else { HelpFileName = helpFileName; } }
public void TestReadCoreEngineSnapIn() { PSSnapInInfo pSSnapInInfo = PSSnapInReader.ReadCoreEngineSnapIn(); Assert.Contains("PublicKeyToken=31bf3856ad364e35", pSSnapInInfo.AssemblyName); }
protected override void ProcessRecord() { foreach (string str in this._pssnapins) { Collection <PSSnapInInfo> snapIns = base.GetSnapIns(str); if (snapIns.Count == 0) { base.WriteNonTerminatingError(str, "NoPSSnapInsFound", PSTraceSource.NewArgumentException(str, "MshSnapInCmdletResources", "NoPSSnapInsFound", new object[] { str }), ErrorCategory.InvalidArgument); } else { foreach (PSSnapInInfo info in snapIns) { if (base.ShouldProcess(info.Name)) { Exception innerException = null; if ((base.Runspace == null) && (base.Context.InitialSessionState != null)) { try { PSSnapInException exception2; PSSnapInInfo.VerifyPSSnapInFormatThrowIfError(info.Name); if (MshConsoleInfo.IsDefaultPSSnapIn(info.Name, base.Context.InitialSessionState.defaultSnapins)) { throw PSTraceSource.NewArgumentException(info.Name, "ConsoleInfoErrorStrings", "CannotRemoveDefault", new object[] { info.Name }); } InitialSessionState state = InitialSessionState.Create(); state.ImportPSSnapIn(info, out exception2); state.Unbind(base.Context); base.Context.InitialSessionState.ImportedSnapins.Remove(info.Name); } catch (PSArgumentException exception3) { innerException = exception3; } if (innerException != null) { base.WriteNonTerminatingError(str, "RemovePSSnapIn", innerException, ErrorCategory.InvalidArgument); } } else { try { PSSnapInException warning = null; PSSnapInInfo sendToPipeline = base.Runspace.RemovePSSnapIn(info.Name, out warning); if (warning != null) { base.WriteNonTerminatingError(info.Name, "RemovePSSnapInRead", warning, ErrorCategory.InvalidData); } if (this._passThru) { sendToPipeline.LoadIndirectResources(base.ResourceReader); base.WriteObject(sendToPipeline); } } catch (PSArgumentException exception5) { innerException = exception5; } if (innerException != null) { base.WriteNonTerminatingError(str, "RemovePSSnapIn", innerException, ErrorCategory.InvalidArgument); } } } } } } }
private Assembly LoadMshSnapinAssembly(PSSnapInInfo mshsnapinInfo) { Assembly assembly = null; s_mshsnapinTracer.WriteLine("Loading assembly from GAC. Assembly Name: {0}", mshsnapinInfo.AssemblyName); try { // WARNING: DUPLICATE CODE see InitialSessionState assembly = Assembly.Load(new AssemblyName(mshsnapinInfo.AssemblyName)); } catch (FileLoadException e) { s_mshsnapinTracer.TraceWarning("Not able to load assembly {0}: {1}", mshsnapinInfo.AssemblyName, e.Message); } catch (BadImageFormatException e) { s_mshsnapinTracer.TraceWarning("Not able to load assembly {0}: {1}", mshsnapinInfo.AssemblyName, e.Message); } catch (FileNotFoundException e) { s_mshsnapinTracer.TraceWarning("Not able to load assembly {0}: {1}", mshsnapinInfo.AssemblyName, e.Message); } if (assembly != null) return assembly; s_mshsnapinTracer.WriteLine("Loading assembly from path: {0}", mshsnapinInfo.AssemblyName); try { AssemblyName assemblyName = ClrFacade.GetAssemblyName(mshsnapinInfo.AbsoluteModulePath); if (string.Compare(assemblyName.FullName, mshsnapinInfo.AssemblyName, StringComparison.OrdinalIgnoreCase) != 0) { string message = StringUtil.Format(ConsoleInfoErrorStrings.PSSnapInAssemblyNameMismatch, mshsnapinInfo.AbsoluteModulePath, mshsnapinInfo.AssemblyName); s_mshsnapinTracer.TraceError(message); throw new PSSnapInException(mshsnapinInfo.Name, message); } assembly = ClrFacade.LoadFrom(mshsnapinInfo.AbsoluteModulePath); } catch (FileLoadException e) { s_mshsnapinTracer.TraceError("Not able to load assembly {0}: {1}", mshsnapinInfo.AssemblyName, e.Message); throw new PSSnapInException(mshsnapinInfo.Name, e.Message); } catch (BadImageFormatException e) { s_mshsnapinTracer.TraceError("Not able to load assembly {0}: {1}", mshsnapinInfo.AssemblyName, e.Message); throw new PSSnapInException(mshsnapinInfo.Name, e.Message); } catch (FileNotFoundException e) { s_mshsnapinTracer.TraceError("Not able to load assembly {0}: {1}", mshsnapinInfo.AssemblyName, e.Message); throw new PSSnapInException(mshsnapinInfo.Name, e.Message); } return assembly; }
private void MergeCustomPSSnapIn(PSSnapInInfo mshsnapinInfo, CustomPSSnapIn customPSSnapIn) { if (mshsnapinInfo == null || customPSSnapIn == null) return; s_mshsnapinTracer.WriteLine("Merging configuration from custom mshsnapin {0}", mshsnapinInfo.Name); if (customPSSnapIn.Cmdlets != null) { foreach (CmdletConfigurationEntry entry in customPSSnapIn.Cmdlets) { CmdletConfigurationEntry cmdlet = new CmdletConfigurationEntry(entry.Name, entry.ImplementingType, entry.HelpFileName, mshsnapinInfo); _cmdlets.AddBuiltInItem(cmdlet); } } if (customPSSnapIn.Providers != null) { foreach (ProviderConfigurationEntry entry in customPSSnapIn.Providers) { ProviderConfigurationEntry provider = new ProviderConfigurationEntry(entry.Name, entry.ImplementingType, entry.HelpFileName, mshsnapinInfo); _providers.AddBuiltInItem(provider); } } if (customPSSnapIn.Types != null) { foreach (TypeConfigurationEntry entry in customPSSnapIn.Types) { string path = Path.Combine(mshsnapinInfo.ApplicationBase, entry.FileName); TypeConfigurationEntry type = new TypeConfigurationEntry(entry.Name, path, mshsnapinInfo); _types.AddBuiltInItem(type); } } if (customPSSnapIn.Formats != null) { foreach (FormatConfigurationEntry entry in customPSSnapIn.Formats) { string path = Path.Combine(mshsnapinInfo.ApplicationBase, entry.FileName); FormatConfigurationEntry format = new FormatConfigurationEntry(entry.Name, path, mshsnapinInfo); _formats.AddBuiltInItem(format); } } AssemblyConfigurationEntry assemblyEntry = new AssemblyConfigurationEntry(mshsnapinInfo.AssemblyName, mshsnapinInfo.AbsoluteModulePath, mshsnapinInfo); this.Assemblies.AddBuiltInItem(assemblyEntry); s_mshsnapinTracer.WriteLine("Configuration from custom mshsnapin {0} merged", mshsnapinInfo.Name); }
private void AnalyzeMshSnapinAssembly(Assembly assembly, PSSnapInInfo mshsnapinInfo) { if (assembly != null) { _mshsnapinTracer.WriteLine("Analyzing assembly {0} for cmdlet and providers", new object[] { assembly.Location }); string helpFile = GetHelpFile(assembly.Location); Type[] exportedTypes = null; try { exportedTypes = assembly.GetExportedTypes(); } catch (ReflectionTypeLoadException exception) { string errorMessageFormat = exception.Message + "\nLoader Exceptions: \n"; if (exception.LoaderExceptions != null) { foreach (Exception exception2 in exception.LoaderExceptions) { errorMessageFormat = errorMessageFormat + "\n" + exception2.Message; } } _mshsnapinTracer.TraceError(errorMessageFormat, new object[0]); throw new PSSnapInException(mshsnapinInfo.Name, errorMessageFormat); } Hashtable hashtable = new Hashtable(StringComparer.OrdinalIgnoreCase); Hashtable hashtable2 = new Hashtable(StringComparer.OrdinalIgnoreCase); foreach (Type type in exportedTypes) { string cmdletName = null; string providerName = null; object[] customAttributes = type.GetCustomAttributes(typeof(CmdletAttribute), false); if (customAttributes.Length > 0) { cmdletName = GetCmdletName(customAttributes[0] as CmdletAttribute); } else { customAttributes = type.GetCustomAttributes(typeof(CmdletProviderAttribute), false); if (customAttributes.Length > 0) { providerName = GetProviderName(customAttributes[0] as CmdletProviderAttribute); } } if (!string.IsNullOrEmpty(cmdletName)) { if (IsCmdletClass(type) && HasDefaultConstructor(type)) { if (hashtable.ContainsKey(cmdletName)) { string str5 = StringUtil.Format(ConsoleInfoErrorStrings.PSSnapInDuplicateCmdlets, cmdletName, mshsnapinInfo.Name); _mshsnapinTracer.TraceError(str5, new object[0]); throw new PSSnapInException(mshsnapinInfo.Name, str5); } hashtable.Add(cmdletName, null); CmdletConfigurationEntry item = new CmdletConfigurationEntry(cmdletName, type, helpFile, mshsnapinInfo); this._cmdlets.AddBuiltInItem(item); _mshsnapinTracer.WriteLine("{0} from type {1} is added as a cmdlet. ", new object[] { cmdletName, type.FullName }); continue; } _mshsnapinTracer.TraceWarning("{0} is not valid cmdlet because it doesn't derive from the Cmdlet type or it doesn't have a default constructor.", new object[] { cmdletName }); } if (!string.IsNullOrEmpty(providerName)) { if (IsProviderClass(type) && HasDefaultConstructor(type)) { if (hashtable2.ContainsKey(providerName)) { string str6 = StringUtil.Format(ConsoleInfoErrorStrings.PSSnapInDuplicateProviders, providerName, mshsnapinInfo.Name); _mshsnapinTracer.TraceError(str6, new object[0]); throw new PSSnapInException(mshsnapinInfo.Name, str6); } hashtable2.Add(providerName, null); ProviderConfigurationEntry entry2 = new ProviderConfigurationEntry(providerName, type, helpFile, mshsnapinInfo); this._providers.AddBuiltInItem(entry2); _mshsnapinTracer.WriteLine("{0} from type {1} is added as a provider. ", new object[] { providerName, type.FullName }); continue; } _mshsnapinTracer.TraceWarning("{0} is not valid provider because it doesn't derive from the provider type or it doesn't have a default constructor.", new object[] { providerName }); } if (typeof(IModuleAssemblyInitializer).IsAssignableFrom(type) && !type.Equals(typeof(IModuleAssemblyInitializer))) { _mshsnapinTracer.TraceWarning("Calling module initializer defined by type {0}", new object[] { type.FullName }); (Activator.CreateInstance(type, true) as IModuleAssemblyInitializer).OnImport(); } } } }
/// <summary> /// Adds one or more snapins /// </summary> /// <param name="snapInList">List of snapin IDs</param> /// <remarks> /// This is a helper method and should not throw any /// exceptions. All exceptions are caught and displayed /// to the user using write* methods /// </remarks> private void AddPSSnapIns(Collection <string> snapInList) { if (snapInList == null) { // nothing to add return; } //BUGBUG TODO - brucepay - this is a workaround for not being able to dynamically update // the set of cmdlets in a runspace if there is no RunspaceConfiguration object. // This is a temporary fix to unblock remoting tests and need to be corrected/completed // before we can ship... // If there is no RunspaceConfig object, then // use an InitialSessionState object to gather and // bind the cmdlets from the snapins... if (Context.RunspaceConfiguration == null) { Collection <PSSnapInInfo> loadedSnapins = base.GetSnapIns(null); InitialSessionState iss = InitialSessionState.Create(); bool isAtleastOneSnapinLoaded = false; foreach (string snapIn in snapInList) { if (InitialSessionState.IsEngineModule(snapIn)) { WriteNonTerminatingError(snapIn, "LoadSystemSnapinAsModule", PSTraceSource.NewArgumentException(snapIn, MshSnapInCmdletResources.LoadSystemSnapinAsModule, snapIn), ErrorCategory.InvalidArgument); } else { PSSnapInException warning; try { // Read snapin data PSSnapInInfo newPSSnapIn = PSSnapInReader.Read(Utils.GetCurrentMajorVersion(), snapIn); PSSnapInInfo psSnapInInfo = IsSnapInLoaded(loadedSnapins, newPSSnapIn); // that means snapin is not already loaded ..so load the snapin // now. if (null == psSnapInInfo) { psSnapInInfo = iss.ImportPSSnapIn(snapIn, out warning); isAtleastOneSnapinLoaded = true; Context.InitialSessionState.ImportedSnapins.Add(psSnapInInfo.Name, psSnapInInfo); } // Write psSnapInInfo object only if passthru is specified. if (_passThru) { // Load the pssnapin info properties that are localizable and redirected in the registry psSnapInInfo.LoadIndirectResources(ResourceReader); WriteObject(psSnapInInfo); } } catch (PSSnapInException pse) { WriteNonTerminatingError(snapIn, "AddPSSnapInRead", pse, ErrorCategory.InvalidData); } } } if (isAtleastOneSnapinLoaded) { // Now update the session state with the new stuff... iss.Bind(Context, /*updateOnly*/ true); } return; } foreach (string psSnapIn in snapInList) { Exception exception = null; try { PSSnapInException warning = null; PSSnapInInfo psSnapInInfo = this.Runspace.AddPSSnapIn(psSnapIn, out warning); if (warning != null) { WriteNonTerminatingError(psSnapIn, "AddPSSnapInRead", warning, ErrorCategory.InvalidData); } // Write psSnapInInfo object only if passthru is specified. if (_passThru) { // Load the pssnapin info properties that are localizable and redirected in the registry psSnapInInfo.LoadIndirectResources(ResourceReader); WriteObject(psSnapInInfo); } } catch (PSArgumentException ae) { exception = ae; } catch (PSSnapInException sle) { exception = sle; } catch (System.Security.SecurityException se) { exception = se; } if (exception != null) { WriteNonTerminatingError(psSnapIn, "AddPSSnapInRead", exception, ErrorCategory.InvalidArgument); } } }
public void LoadCmdletsFromAssembly(Assembly assembly, PSSnapInInfo snapinInfo) { LoadCmdletsFromAssembly(assembly, snapinInfo, null); }
private void LoadPSSnapIn(PSSnapInInfo mshsnapinInfo) { if (mshsnapinInfo == null) return; #if !CORECLR // CustomPSSnapIn Not Supported On CSS. if (!String.IsNullOrEmpty(mshsnapinInfo.CustomPSSnapInType)) { LoadCustomPSSnapIn(mshsnapinInfo); return; } #endif Assembly assembly = null; s_mshsnapinTracer.WriteLine("Loading assembly for mshsnapin {0}", mshsnapinInfo.Name); assembly = LoadMshSnapinAssembly(mshsnapinInfo); if (assembly == null) { s_mshsnapinTracer.TraceError("Loading assembly for mshsnapin {0} failed", mshsnapinInfo.Name); return; } s_mshsnapinTracer.WriteLine("Loading assembly for mshsnapin {0} succeeded", mshsnapinInfo.Name); Dictionary<string, SessionStateCmdletEntry> cmdlets = null; Dictionary<string, List<SessionStateAliasEntry>> aliases = null; Dictionary<string, SessionStateProviderEntry> providers = null; string throwAwayHelpFile = null; PSSnapInHelpers.AnalyzePSSnapInAssembly(assembly, assembly.Location, mshsnapinInfo, null, false, out cmdlets, out aliases, out providers, out throwAwayHelpFile); if (cmdlets != null) { foreach (var c in cmdlets) { CmdletConfigurationEntry cmdlet = new CmdletConfigurationEntry(c.Key, c.Value.ImplementingType, c.Value.HelpFileName, mshsnapinInfo); _cmdlets.AddBuiltInItem(cmdlet); } } if (providers != null) { foreach (var p in providers) { ProviderConfigurationEntry provider = new ProviderConfigurationEntry(p.Key, p.Value.ImplementingType, p.Value.HelpFileName, mshsnapinInfo); _providers.AddBuiltInItem(provider); } } foreach (string file in mshsnapinInfo.Types) { string path = Path.Combine(mshsnapinInfo.ApplicationBase, file); TypeConfigurationEntry typeEntry = new TypeConfigurationEntry(path, path, mshsnapinInfo); this.Types.AddBuiltInItem(typeEntry); } foreach (string file in mshsnapinInfo.Formats) { string path = Path.Combine(mshsnapinInfo.ApplicationBase, file); FormatConfigurationEntry formatEntry = new FormatConfigurationEntry(path, path, mshsnapinInfo); this.Formats.AddBuiltInItem(formatEntry); } AssemblyConfigurationEntry assemblyEntry = new AssemblyConfigurationEntry(mshsnapinInfo.AssemblyName, mshsnapinInfo.AbsoluteModulePath, mshsnapinInfo); this.Assemblies.AddBuiltInItem(assemblyEntry); return; }
internal static Assembly LoadPSSnapInAssembly( PSSnapInInfo psSnapInInfo, out Dictionary <string, SessionStateCmdletEntry> cmdlets, out Dictionary <string, SessionStateProviderEntry> providers) { Assembly assembly1 = (Assembly)null; cmdlets = (Dictionary <string, SessionStateCmdletEntry>)null; providers = (Dictionary <string, SessionStateProviderEntry>)null; PSSnapInHelpers._PSSnapInTracer.WriteLine("Loading assembly from GAC. Assembly Name: {0}", (object)psSnapInInfo.AssemblyName); try { assembly1 = Assembly.Load(psSnapInInfo.AssemblyName); } catch (FileLoadException ex) { PSSnapInHelpers._PSSnapInTracer.TraceWarning("Not able to load assembly {0}: {1}", (object)psSnapInInfo.AssemblyName, (object)ex.Message); } catch (BadImageFormatException ex) { PSSnapInHelpers._PSSnapInTracer.TraceWarning("Not able to load assembly {0}: {1}", (object)psSnapInInfo.AssemblyName, (object)ex.Message); } catch (FileNotFoundException ex) { PSSnapInHelpers._PSSnapInTracer.TraceWarning("Not able to load assembly {0}: {1}", (object)psSnapInInfo.AssemblyName, (object)ex.Message); } if (assembly1 != null) { return(assembly1); } PSSnapInHelpers._PSSnapInTracer.WriteLine("Loading assembly from path: {0}", (object)psSnapInInfo.AssemblyName); try { Assembly assembly2 = Assembly.ReflectionOnlyLoadFrom(psSnapInInfo.AbsoluteModulePath); if (assembly2 == null) { return((Assembly)null); } if (!string.Equals(assembly2.FullName, psSnapInInfo.AssemblyName, StringComparison.OrdinalIgnoreCase)) { string str = ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "PSSnapInAssemblyNameMismatch", (object)psSnapInInfo.AbsoluteModulePath, (object)psSnapInInfo.AssemblyName); PSSnapInHelpers._PSSnapInTracer.TraceError(str); throw new PSSnapInException(psSnapInInfo.Name, str); } return(Assembly.LoadFrom(psSnapInInfo.AbsoluteModulePath)); } catch (FileLoadException ex) { PSSnapInHelpers._PSSnapInTracer.TraceError("Not able to load assembly {0}: {1}", (object)psSnapInInfo.AssemblyName, (object)ex.Message); throw new PSSnapInException(psSnapInInfo.Name, ex.Message); } catch (BadImageFormatException ex) { PSSnapInHelpers._PSSnapInTracer.TraceError("Not able to load assembly {0}: {1}", (object)psSnapInInfo.AssemblyName, (object)ex.Message); throw new PSSnapInException(psSnapInInfo.Name, ex.Message); } catch (FileNotFoundException ex) { PSSnapInHelpers._PSSnapInTracer.TraceError("Not able to load assembly {0}: {1}", (object)psSnapInInfo.AssemblyName, (object)ex.Message); throw new PSSnapInException(psSnapInInfo.Name, ex.Message); } }
private void LoadCustomPSSnapIn(PSSnapInInfo mshsnapinInfo) { if (mshsnapinInfo == null) return; if (String.IsNullOrEmpty(mshsnapinInfo.CustomPSSnapInType)) { return; } Assembly assembly = null; s_mshsnapinTracer.WriteLine("Loading assembly for mshsnapin {0}", mshsnapinInfo.Name); assembly = LoadMshSnapinAssembly(mshsnapinInfo); if (assembly == null) { s_mshsnapinTracer.TraceError("Loading assembly for mshsnapin {0} failed", mshsnapinInfo.Name); return; } CustomPSSnapIn customPSSnapIn = null; try { Type type = assembly.GetType(mshsnapinInfo.CustomPSSnapInType, true, false); if (type != null) { customPSSnapIn = (CustomPSSnapIn)Activator.CreateInstance(type); } s_mshsnapinTracer.WriteLine("Loading assembly for mshsnapin {0} succeeded", mshsnapinInfo.Name); } catch (TypeLoadException tle) { throw new PSSnapInException(mshsnapinInfo.Name, tle.Message); } catch (ArgumentException ae) { throw new PSSnapInException(mshsnapinInfo.Name, ae.Message); } catch (MissingMethodException mme) { throw new PSSnapInException(mshsnapinInfo.Name, mme.Message); } catch (InvalidCastException ice) { throw new PSSnapInException(mshsnapinInfo.Name, ice.Message); } catch (TargetInvocationException tie) { if (tie.InnerException != null) { throw new PSSnapInException(mshsnapinInfo.Name, tie.InnerException.Message); } throw new PSSnapInException(mshsnapinInfo.Name, tie.Message); } MergeCustomPSSnapIn(mshsnapinInfo, customPSSnapIn); return; }
private void ProcessSnapIn(PSSnapInInfo snapinInfo) { ProcessPath(PscxPathInfo.GetPscxPathInfo(this.SessionState, snapinInfo.ModuleName)); }
/// <summary> /// Routine to get the list of loaded snapins... /// </summary> /// <returns></returns> protected internal Collection <PSSnapInInfo> GetSnapIns(string pattern) { // If RunspaceConfiguration is not null, then return the list that it has if (Runspace != null) { if (pattern != null) { return(Runspace.ConsoleInfo.GetPSSnapIn(pattern, _shouldGetAll)); } else { return(Runspace.ConsoleInfo.PSSnapIns); } } WildcardPattern matcher = null; if (!String.IsNullOrEmpty(pattern)) { bool doWildCardSearch = WildcardPattern.ContainsWildcardCharacters(pattern); if (!doWildCardSearch) { // Verify PSSnapInID.. // This will throw if it not a valid name PSSnapInInfo.VerifyPSSnapInFormatThrowIfError(pattern); } matcher = WildcardPattern.Get(pattern, WildcardOptions.IgnoreCase); } Collection <PSSnapInInfo> snapins = new Collection <PSSnapInInfo>(); if (_shouldGetAll) { foreach (PSSnapInInfo snapinKey in PSSnapInReader.ReadAll()) { if (matcher == null || matcher.IsMatch(snapinKey.Name)) { snapins.Add(snapinKey); } } } else { // Otherwise, just scan through the list of cmdlets and rebuild the table. List <CmdletInfo> cmdlets = InvokeCommand.GetCmdlets(); Dictionary <PSSnapInInfo, bool> snapinTable = new Dictionary <PSSnapInInfo, bool>(); foreach (CmdletInfo cmdlet in cmdlets) { PSSnapInInfo snapin = cmdlet.PSSnapIn; if (snapin != null && !snapinTable.ContainsKey(snapin)) { snapinTable.Add(snapin, true); } } foreach (PSSnapInInfo snapinKey in snapinTable.Keys) { if (matcher == null || matcher.IsMatch(snapinKey.Name)) { snapins.Add(snapinKey); } } } return(snapins); }
/// <summary> /// See if the snapin is already loaded..returns load snapin info if true, null otherwise. /// </summary> /// <returns></returns> internal static PSSnapInInfo IsSnapInLoaded(Collection <PSSnapInInfo> loadedSnapins, PSSnapInInfo psSnapInInfo) { if (null == loadedSnapins) { return(null); } foreach (PSSnapInInfo loadedPSSnapInInfo in loadedSnapins) { // See if the assembly-qualified names match and return the existing PSSnapInInfo // if they do. string loadedSnapInAssemblyName = loadedPSSnapInInfo.AssemblyName; if (string.Equals(loadedPSSnapInInfo.Name, psSnapInInfo.Name, StringComparison.OrdinalIgnoreCase) && !string.IsNullOrEmpty(loadedSnapInAssemblyName) && string.Equals(loadedSnapInAssemblyName, psSnapInInfo.AssemblyName, System.StringComparison.OrdinalIgnoreCase)) { return(loadedPSSnapInInfo); } } return(null); }
/// <summary> /// Load help file provided. /// </summary> /// <remarks> /// This will load providerHelpInfo from help file into help cache. /// </remarks> /// <param name="providerInfo">ProviderInfo for which to locate help.</param> private void LoadHelpFile(ProviderInfo providerInfo) { if (providerInfo == null) { throw PSTraceSource.NewArgumentNullException(nameof(providerInfo)); } string helpFile = providerInfo.HelpFile; if (string.IsNullOrEmpty(helpFile) || _helpFiles.Contains(helpFile)) { return; } string helpFileToLoad = helpFile; // Get the mshsnapinfo object for this cmdlet. PSSnapInInfo mshSnapInInfo = providerInfo.PSSnapIn; // Search fallback // 1. If PSSnapInInfo exists, then always look in the application base // of the mshsnapin // Otherwise, // Look in the default search path and cmdlet assembly path Collection <string> searchPaths = new Collection <string>(); if (mshSnapInInfo != null) { Diagnostics.Assert(!string.IsNullOrEmpty(mshSnapInInfo.ApplicationBase), "Application Base is null or empty."); // not minishell case.. // we have to search only in the application base for a mshsnapin... // if you create an absolute path for helpfile, then MUIFileSearcher // will look only in that path. helpFileToLoad = Path.Combine(mshSnapInInfo.ApplicationBase, helpFile); } else if ((providerInfo.Module != null) && (!string.IsNullOrEmpty(providerInfo.Module.Path))) { helpFileToLoad = Path.Combine(providerInfo.Module.ModuleBase, helpFile); } else { searchPaths.Add(GetDefaultShellSearchPath()); searchPaths.Add(GetProviderAssemblyPath(providerInfo)); } string location = MUIFileSearcher.LocateFile(helpFileToLoad, searchPaths); if (string.IsNullOrEmpty(location)) { throw new FileNotFoundException(helpFile); } XmlDocument doc = InternalDeserializer.LoadUnsafeXmlDocument( new FileInfo(location), false, /* ignore whitespace, comments, etc. */ null); /* default maxCharactersInDocument */ // Add this file into _helpFiles hashtable to prevent it to be loaded again. _helpFiles[helpFile] = 0; XmlNode helpItemsNode = null; if (doc.HasChildNodes) { for (int i = 0; i < doc.ChildNodes.Count; i++) { XmlNode node = doc.ChildNodes[i]; if (node.NodeType == XmlNodeType.Element && string.Equals(node.Name, "helpItems", StringComparison.OrdinalIgnoreCase)) { helpItemsNode = node; break; } } } if (helpItemsNode == null) { return; } using (this.HelpSystem.Trace(location)) { if (helpItemsNode.HasChildNodes) { for (int i = 0; i < helpItemsNode.ChildNodes.Count; i++) { XmlNode node = helpItemsNode.ChildNodes[i]; if (node.NodeType == XmlNodeType.Element && string.Equals(node.Name, "providerHelp", StringComparison.OrdinalIgnoreCase)) { HelpInfo helpInfo = ProviderHelpInfo.Load(node); if (helpInfo != null) { this.HelpSystem.TraceErrors(helpInfo.Errors); // Add snapin qualified type name for this command.. // this will enable customizations of the help object. helpInfo.FullHelp.TypeNames.Insert(0, string.Format(CultureInfo.InvariantCulture, "ProviderHelpInfo#{0}#{1}", providerInfo.PSSnapInName, helpInfo.Name)); if (!string.IsNullOrEmpty(providerInfo.PSSnapInName)) { helpInfo.FullHelp.Properties.Add(new PSNoteProperty("PSSnapIn", providerInfo.PSSnapIn)); helpInfo.FullHelp.TypeNames.Insert(1, string.Format(CultureInfo.InvariantCulture, "ProviderHelpInfo#{0}", providerInfo.PSSnapInName)); } AddCache(providerInfo.PSSnapInName + "\\" + helpInfo.Name, helpInfo); } } } } } }
internal static void AnalyzePSSnapInAssembly( Assembly assembly, string name, PSSnapInInfo psSnapInInfo, out Dictionary <string, SessionStateCmdletEntry> cmdlets, out Dictionary <string, SessionStateProviderEntry> providers) { if (assembly == null) { throw new ArgumentNullException(nameof(assembly)); } if (PSSnapInHelpers._cmdletCache != null && PSSnapInHelpers._providerCache != null && (PSSnapInHelpers._cmdletCache.ContainsKey(assembly) && PSSnapInHelpers._providerCache.ContainsKey(assembly))) { cmdlets = PSSnapInHelpers._cmdletCache[assembly]; providers = PSSnapInHelpers._providerCache[assembly]; } else { cmdlets = (Dictionary <string, SessionStateCmdletEntry>)null; providers = (Dictionary <string, SessionStateProviderEntry>)null; PSSnapInHelpers._PSSnapInTracer.WriteLine("Analyzing assembly {0} for cmdlet and providers", (object)assembly.Location); string helpFile = PSSnapInHelpers.GetHelpFile(assembly.Location); Type[] types; try { types = assembly.GetTypes(); } catch (ReflectionTypeLoadException ex) { string str = ex.Message + "\nLoader Exceptions: \n"; if (ex.LoaderExceptions != null) { foreach (Exception loaderException in ex.LoaderExceptions) { str = str + "\n" + loaderException.Message; } } PSSnapInHelpers._PSSnapInTracer.TraceError(str); throw new PSSnapInException(name, str); } foreach (Type type in types) { if ((type.IsPublic || type.IsNestedPublic) && !type.IsAbstract) { object[] customAttributes = type.GetCustomAttributes(false); string str1 = (string)null; string str2 = (string)null; foreach (object obj in customAttributes) { if (obj.GetType() == typeof(CmdletAttribute)) { str1 = PSSnapInHelpers.GetCmdletName(obj as CmdletAttribute); break; } if (obj.GetType() == typeof(CmdletProviderAttribute)) { str2 = PSSnapInHelpers.GetProviderName(obj as CmdletProviderAttribute); break; } } if (!string.IsNullOrEmpty(str1)) { if (PSSnapInHelpers.IsCmdletClass(type) && PSSnapInHelpers.HasDefaultConstructor(type)) { if (cmdlets != null && cmdlets.ContainsKey(str1)) { string str3 = ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "PSSnapInDuplicateCmdlets", (object)str1, (object)name); PSSnapInHelpers._PSSnapInTracer.TraceError(str3); throw new PSSnapInException(name, str3); } SessionStateCmdletEntry stateCmdletEntry = new SessionStateCmdletEntry(str1, type, helpFile); if (psSnapInInfo != null) { stateCmdletEntry.SetPSSnapIn(psSnapInInfo); } if (cmdlets == null) { cmdlets = new Dictionary <string, SessionStateCmdletEntry>((IEqualityComparer <string>)StringComparer.OrdinalIgnoreCase); } cmdlets.Add(str1, stateCmdletEntry); PSSnapInHelpers._PSSnapInTracer.WriteLine("{0} from type {1} is added as a cmdlet. ", (object)str1, (object)type.FullName); continue; } PSSnapInHelpers._PSSnapInTracer.TraceWarning("{0} is not valid cmdlet because it doesn't derive from the Cmdlet type or it doesn't have a default constructor.", (object)str1); } if (!string.IsNullOrEmpty(str2)) { if (PSSnapInHelpers.IsProviderClass(type) && PSSnapInHelpers.HasDefaultConstructor(type)) { if (providers != null && providers.ContainsKey(str2)) { string str3 = ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "PSSnapInDuplicateProviders", (object)str2, (object)psSnapInInfo.Name); PSSnapInHelpers._PSSnapInTracer.TraceError(str3); throw new PSSnapInException(psSnapInInfo.Name, str3); } SessionStateProviderEntry stateProviderEntry = new SessionStateProviderEntry(str2, type, helpFile); stateProviderEntry.SetPSSnapIn(psSnapInInfo); if (providers == null) { providers = new Dictionary <string, SessionStateProviderEntry>((IEqualityComparer <string>)StringComparer.OrdinalIgnoreCase); } providers.Add(str2, stateProviderEntry); PSSnapInHelpers._PSSnapInTracer.WriteLine("{0} from type {1} is added as a provider. ", (object)str2, (object)type.FullName); } else { PSSnapInHelpers._PSSnapInTracer.TraceWarning("{0} is not valid provider because it doesn't derive from the provider type or it doesn't have a default constructor.", (object)str2); } } } } lock (PSSnapInHelpers._syncObject) { if (cmdlets != null) { if (PSSnapInHelpers._cmdletCache == null) { PSSnapInHelpers._cmdletCache = new Dictionary <Assembly, Dictionary <string, SessionStateCmdletEntry> >(); } PSSnapInHelpers._cmdletCache[assembly] = cmdlets; } if (providers == null) { return; } if (PSSnapInHelpers._providerCache == null) { PSSnapInHelpers._providerCache = new Dictionary <Assembly, Dictionary <string, SessionStateProviderEntry> >(); } PSSnapInHelpers._providerCache[assembly] = providers; } } }
/// <summary> /// Removes pssnapins from the current console file. /// </summary> /// <remarks> /// The pssnapin is not unloaded from the current engine. So all the cmdlets that are /// represented by this pssnapin will continue to work. /// </remarks> protected override void ProcessRecord() { foreach (string psSnapIn in _pssnapins) { Collection <PSSnapInInfo> snapIns = GetSnapIns(psSnapIn); // snapIns won't be null.. Diagnostics.Assert(snapIns != null, "GetSnapIns() returned null"); if (snapIns.Count == 0) { WriteNonTerminatingError(psSnapIn, "NoPSSnapInsFound", PSTraceSource.NewArgumentException(psSnapIn, MshSnapInCmdletResources.NoPSSnapInsFound, psSnapIn), ErrorCategory.InvalidArgument); continue; } foreach (PSSnapInInfo snapIn in snapIns) { // confirm the operation first // this is always false if WhatIf is set if (ShouldProcess(snapIn.Name)) { Exception exception = null; if (this.Runspace == null && this.Context.InitialSessionState != null) { try { // Check if this snapin can be removed // Monad has specific restrictions on the mshsnapinid like // mshsnapinid should be A-Za-z0-9.-_ etc. PSSnapInInfo.VerifyPSSnapInFormatThrowIfError(snapIn.Name); if (MshConsoleInfo.IsDefaultPSSnapIn(snapIn.Name, this.Context.InitialSessionState.defaultSnapins)) { throw PSTraceSource.NewArgumentException(snapIn.Name, ConsoleInfoErrorStrings.CannotRemoveDefault, snapIn.Name); } // Handle the initial session state case... InitialSessionState iss = InitialSessionState.Create(); PSSnapInException warning; // Get the snapin information... iss.ImportPSSnapIn(snapIn, out warning); iss.Unbind(Context); Context.InitialSessionState.ImportedSnapins.Remove(snapIn.Name); } catch (PSArgumentException ae) { exception = ae; } if (exception != null) { WriteNonTerminatingError(psSnapIn, "RemovePSSnapIn", exception, ErrorCategory.InvalidArgument); } } else { try { PSSnapInException warning = null; PSSnapInInfo psSnapInInfo = this.Runspace.RemovePSSnapIn(snapIn.Name, out warning); if (warning != null) { WriteNonTerminatingError(snapIn.Name, "RemovePSSnapInRead", warning, ErrorCategory.InvalidData); } if (_passThru) { // Load the pssnapin info properties that are localizable and redirected in the registry psSnapInInfo.LoadIndirectResources(ResourceReader); WriteObject(psSnapInInfo); } } catch (PSArgumentException ae) { exception = ae; } if (exception != null) { WriteNonTerminatingError(psSnapIn, "RemovePSSnapIn", exception, ErrorCategory.InvalidArgument); } } } // ShouldContinue } } }