protected override void EndProcessing() { if ((this._numberRemoved == 0) && !base.MyInvocation.BoundParameters.ContainsKey("WhatIf")) { bool flag = true; bool flag2 = true; foreach (string str in this._name) { if (!InitialSessionState.IsEngineModule(str)) { flag2 = false; } if (!WildcardPattern.ContainsWildcardCharacters(str)) { flag = false; } } if (!flag2 && (!flag || (this._moduleInfo.Length != 0))) { InvalidOperationException exception = new InvalidOperationException(StringUtil.Format(Modules.NoModulesRemoved, new object[0])); ErrorRecord errorRecord = new ErrorRecord(exception, "Modules_NoModulesRemoved", ErrorCategory.ResourceUnavailable, null); base.WriteError(errorRecord); } } }
/// <summary> /// Reports an error if no modules were removed... /// </summary> protected override void EndProcessing() { // Write an error record if specific modules were to be removed. // By specific, we mean either a name sting with no wildcards or // or a PSModuleInfo object. If the removal request only includes patterns // then we won't write the error. if (_numberRemoved == 0 && !MyInvocation.BoundParameters.ContainsKey("WhatIf")) { bool hasWildcards = true; bool isEngineModule = true; foreach (string n in _name) { if (!InitialSessionState.IsEngineModule(n)) { isEngineModule = false; } if (!WildcardPattern.ContainsWildcardCharacters(n)) { hasWildcards = false; } } if (FullyQualifiedName != null && (FullyQualifiedName.Any(static moduleSpec => !InitialSessionState.IsEngineModule(moduleSpec.Name))))
private void ProcessSingleModuleObject(PSModuleInfo module, ExecutionContext context, Dictionary <Tuple <string, Version>, UpdatableHelpModuleInfo> helpModules, bool noErrors) { if (InitialSessionState.IsEngineModule(module.Name) && !InitialSessionState.IsNestedEngineModule(module.Name)) { WriteDebug(StringUtil.Format("Found engine module: {0}, {1}.", module.Name, module.Guid)); var keyTuple = new Tuple <string, Version>(module.Name, module.Version); if (!helpModules.ContainsKey(keyTuple)) { helpModules.Add(keyTuple, new UpdatableHelpModuleInfo(module.Name, module.Guid, Utils.GetApplicationBase(context.ShellID), s_metadataCache[module.Name])); } return; } else if (InitialSessionState.IsNestedEngineModule(module.Name)) { return; } if (string.IsNullOrEmpty(module.HelpInfoUri)) { if (!noErrors) { ProcessException(module.Name, null, new UpdatableHelpSystemException( "HelpInfoUriNotFound", StringUtil.Format(HelpDisplayStrings.HelpInfoUriNotFound), ErrorCategory.NotSpecified, new Uri("HelpInfoUri", UriKind.Relative), null)); } return; } if (!(module.HelpInfoUri.StartsWith("http://", StringComparison.OrdinalIgnoreCase) || module.HelpInfoUri.StartsWith("https://", StringComparison.OrdinalIgnoreCase))) { if (!noErrors) { ProcessException(module.Name, null, new UpdatableHelpSystemException( "InvalidHelpInfoUriFormat", StringUtil.Format(HelpDisplayStrings.InvalidHelpInfoUriFormat, module.HelpInfoUri), ErrorCategory.NotSpecified, new Uri("HelpInfoUri", UriKind.Relative), null)); } return; } var keyTuple2 = new Tuple <string, Version>(module.Name, module.Version); if (!helpModules.ContainsKey(keyTuple2)) { helpModules.Add(keyTuple2, new UpdatableHelpModuleInfo(module.Name, module.Guid, module.ModuleBase, module.HelpInfoUri)); } }
private string FindHelpFile(CmdletInfo cmdletInfo) { if (cmdletInfo == null) { throw PSTraceSource.NewArgumentNullException("cmdletInfo"); } string helpFile = cmdletInfo.HelpFile; if (string.IsNullOrEmpty(helpFile)) { if ((cmdletInfo.Module != null) && InitialSessionState.IsEngineModule(cmdletInfo.Module.Name)) { return(Path.Combine(cmdletInfo.Module.ModuleBase, Thread.CurrentThread.CurrentCulture.Name, engineModuleHelpFileCache[cmdletInfo.Module.Name])); } return(helpFile); } string file = helpFile; PSSnapInInfo pSSnapIn = cmdletInfo.PSSnapIn; Collection <string> searchPaths = new Collection <string>(); if (pSSnapIn != null) { file = Path.Combine(pSSnapIn.ApplicationBase, helpFile); } else if ((cmdletInfo.Module != null) && !string.IsNullOrEmpty(cmdletInfo.Module.Path)) { file = Path.Combine(cmdletInfo.Module.ModuleBase, helpFile); } else { searchPaths.Add(base.GetDefaultShellSearchPath()); searchPaths.Add(GetCmdletAssemblyPath(cmdletInfo)); } string str3 = MUIFileSearcher.LocateFile(file, searchPaths); if (string.IsNullOrEmpty(str3)) { tracer.WriteLine("Unable to load file {0}", new object[] { file }); } return(str3); }
/// <summary> /// Reports an error if no modules were removed... /// </summary> protected override void EndProcessing() { // Write an error record if specific modules were to be removed. // By specific, we mean either a name sting with no wildcards or // or a PSModuleInfo object. If the removal request only includes patterns // then we won't write the error. if (_numberRemoved == 0 && !MyInvocation.BoundParameters.ContainsKey("WhatIf")) { bool hasWildcards = true; bool isEngineModule = true; foreach (string n in _name) { if (!InitialSessionState.IsEngineModule(n)) { isEngineModule = false; } if (!WildcardPattern.ContainsWildcardCharacters(n)) { hasWildcards = false; } } if (FullyQualifiedName != null && (FullyQualifiedName.Any(moduleSpec => !InitialSessionState.IsEngineModule(moduleSpec.Name)))) { isEngineModule = false; } if (!isEngineModule && (!hasWildcards || _moduleInfo.Length != 0 || (FullyQualifiedName != null && FullyQualifiedName.Length != 0))) { string message = StringUtil.Format(Modules.NoModulesRemoved); InvalidOperationException invalidOp = new InvalidOperationException(message); ErrorRecord er = new ErrorRecord(invalidOp, "Modules_NoModulesRemoved", ErrorCategory.ResourceUnavailable, null); WriteError(er); } } }
private int _numberRemoved = 0; // Maintains a count of the number of modules removed... /// <summary> /// Remove the specified modules. Modules can be specified either through a ModuleInfo or a name. /// </summary> protected override void ProcessRecord() { // This dictionary has the list of modules to be removed. // Key - Module specified as a parameter to Remove-Module // Values - List of all modules that need to be removed for this key (includes all nested modules of this module) Dictionary <PSModuleInfo, List <PSModuleInfo> > modulesToRemove = new Dictionary <PSModuleInfo, List <PSModuleInfo> >(); foreach (var m in Context.Modules.GetModules(_name, false)) { modulesToRemove.Add(m, new List <PSModuleInfo> { m }); } if (FullyQualifiedName != null) { foreach (var m in Context.Modules.GetModules(FullyQualifiedName, false)) { modulesToRemove.Add(m, new List <PSModuleInfo> { m }); } } foreach (var m in _moduleInfo) { modulesToRemove.Add(m, new List <PSModuleInfo> { m }); } // Add any of the child modules of a manifests to the list of modules to remove... Dictionary <PSModuleInfo, List <PSModuleInfo> > nestedModules = new Dictionary <PSModuleInfo, List <PSModuleInfo> >(); foreach (var entry in modulesToRemove) { var module = entry.Key; if (module.NestedModules != null && module.NestedModules.Count > 0) { List <PSModuleInfo> nestedModulesWithNoCircularReference = new List <PSModuleInfo>(); GetAllNestedModules(module, ref nestedModulesWithNoCircularReference); nestedModules.Add(module, nestedModulesWithNoCircularReference); } } // dont add duplicates to our original modulesToRemove list..so that the // evaluation loop below will not duplicate in case of WriteError and WriteWarning. // A global list of modules to be removed is maintained for this purpose HashSet <PSModuleInfo> globalListOfModules = new HashSet <PSModuleInfo>(new PSModuleInfoComparer()); if (nestedModules.Count > 0) { foreach (var entry in nestedModules) { List <PSModuleInfo> values = null; if (modulesToRemove.TryGetValue(entry.Key, out values)) { foreach (var module in entry.Value) { if (!globalListOfModules.Contains(module)) { values.Add(module); globalListOfModules.Add(module); } } } } } // Check the list of modules to remove and exclude those that cannot or should not be removed Dictionary <PSModuleInfo, List <PSModuleInfo> > actualModulesToRemove = new Dictionary <PSModuleInfo, List <PSModuleInfo> >(); // We want to remove the modules starting from the nested modules // If we start from the parent module, the nested modules do not get removed and are left orphaned in the parent modules's sessionstate. foreach (var entry in modulesToRemove) { List <PSModuleInfo> moduleList = new List <PSModuleInfo>(); for (int i = entry.Value.Count - 1; i >= 0; i--) { PSModuleInfo module = entry.Value[i]; // See if the module is constant... if (module.AccessMode == ModuleAccessMode.Constant) { string message = StringUtil.Format(Modules.ModuleIsConstant, module.Name); InvalidOperationException moduleNotRemoved = new InvalidOperationException(message); ErrorRecord er = new ErrorRecord(moduleNotRemoved, "Modules_ModuleIsConstant", ErrorCategory.PermissionDenied, module); WriteError(er); continue; } // See if the module is readonly... if (module.AccessMode == ModuleAccessMode.ReadOnly && !BaseForce) { string message = StringUtil.Format(Modules.ModuleIsReadOnly, module.Name); if (InitialSessionState.IsConstantEngineModule(module.Name)) { WriteWarning(message); } else { InvalidOperationException moduleNotRemoved = new InvalidOperationException(message); ErrorRecord er = new ErrorRecord(moduleNotRemoved, "Modules_ModuleIsReadOnly", ErrorCategory.PermissionDenied, module); WriteError(er); } continue; } if (!ShouldProcess(StringUtil.Format(Modules.ConfirmRemoveModule, module.Name, module.Path))) { continue; } // If this module provides the current session drive, then we cannot remove it. // Abort this command since we don't want to do a partial removal of a module manifest. if (ModuleProvidesCurrentSessionDrive(module)) { if (InitialSessionState.IsEngineModule(module.Name)) { if (!BaseForce) { string message = StringUtil.Format(Modules.CoreModuleCannotBeRemoved, module.Name); this.WriteWarning(message); } continue; } // Specify the overall module name if there is only one. // Otherwise specify the particular module name. string moduleName = (_name.Length == 1) ? _name[0] : module.Name; PSInvalidOperationException invalidOperation = PSTraceSource.NewInvalidOperationException( Modules.ModuleDriveInUse, moduleName); throw (invalidOperation); } // Add module to remove list. moduleList.Add(module); } actualModulesToRemove[entry.Key] = moduleList; } // Now remove the modules, first checking the RequiredModules dependencies Dictionary <PSModuleInfo, List <PSModuleInfo> > requiredDependencies = GetRequiredDependencies(); foreach (var entry in actualModulesToRemove) { foreach (var module in entry.Value) { if (!BaseForce) { List <PSModuleInfo> requiredBy = null; if (requiredDependencies.TryGetValue(module, out requiredBy)) { for (int i = requiredBy.Count - 1; i >= 0; i--) { if (actualModulesToRemove.ContainsKey(requiredBy[i])) { requiredBy.RemoveAt(i); } } if (requiredBy.Count > 0) { string message = StringUtil.Format(Modules.ModuleIsRequired, module.Name, requiredBy[0].Name); InvalidOperationException moduleNotRemoved = new InvalidOperationException(message); ErrorRecord er = new ErrorRecord(moduleNotRemoved, "Modules_ModuleIsRequired", ErrorCategory.PermissionDenied, module); WriteError(er); continue; } } } _numberRemoved++; this.RemoveModule(module, entry.Key.Name); } } }
/// <summary> /// Gets a list of matching commands. /// </summary> /// <param name="pattern">Command pattern.</param> /// <param name="context">Execution context.</param> /// <param name="commandOrigin">Command origin.</param> /// <param name="rediscoverImportedModules">If true, rediscovers imported modules.</param> /// <param name="moduleVersionRequired">Specific module version to be required.</param> /// <param name="useFuzzyMatching">Use fuzzy matching.</param> /// <param name="useAbbreviationExpansion">Use abbreviation expansion for matching.</param> /// <returns>Returns matching CommandInfo IEnumerable.</returns> internal static IEnumerable <CommandInfo> GetMatchingCommands(string pattern, ExecutionContext context, CommandOrigin commandOrigin, bool rediscoverImportedModules = false, bool moduleVersionRequired = false, bool useFuzzyMatching = false, bool useAbbreviationExpansion = false) { // Otherwise, if it had wildcards, just return the "AvailableCommand" // type of command info. WildcardPattern commandPattern = WildcardPattern.Get(pattern, WildcardOptions.IgnoreCase); CmdletInfo cmdletInfo = context.SessionState.InvokeCommand.GetCmdlet("Microsoft.PowerShell.Core\\Get-Module"); PSModuleAutoLoadingPreference moduleAutoLoadingPreference = CommandDiscovery.GetCommandDiscoveryPreference(context, SpecialVariables.PSModuleAutoLoadingPreferenceVarPath, "PSModuleAutoLoadingPreference"); if ((moduleAutoLoadingPreference != PSModuleAutoLoadingPreference.None) && ((commandOrigin == CommandOrigin.Internal) || ((cmdletInfo != null) && (cmdletInfo.Visibility == SessionStateEntryVisibility.Public)))) { foreach (string modulePath in GetDefaultAvailableModuleFiles(isForAutoDiscovery: false, context)) { // Skip modules that have already been loaded so that we don't expose private commands. string moduleName = Path.GetFileNameWithoutExtension(modulePath); List <PSModuleInfo> modules = context.Modules.GetExactMatchModules(moduleName, all: false, exactMatch: true); PSModuleInfo tempModuleInfo = null; if (modules.Count != 0) { // 1. We continue to the next module path if we don't want to re-discover those imported modules // 2. If we want to re-discover the imported modules, but one or more commands from the module were made private, // then we don't do re-discovery if (!rediscoverImportedModules || modules.Exists(module => module.ModuleHasPrivateMembers)) { continue; } if (modules.Count == 1) { PSModuleInfo psModule = modules[0]; tempModuleInfo = new PSModuleInfo(psModule.Name, psModule.Path, context: null, sessionState: null); tempModuleInfo.SetModuleBase(psModule.ModuleBase); foreach (KeyValuePair <string, CommandInfo> entry in psModule.ExportedCommands) { if (commandPattern.IsMatch(entry.Value.Name) || (useFuzzyMatching && FuzzyMatcher.IsFuzzyMatch(entry.Value.Name, pattern)) || (useAbbreviationExpansion && string.Equals(pattern, AbbreviateName(entry.Value.Name), StringComparison.OrdinalIgnoreCase))) { CommandInfo current = null; switch (entry.Value.CommandType) { case CommandTypes.Alias: current = new AliasInfo(entry.Value.Name, definition: null, context); break; case CommandTypes.Function: current = new FunctionInfo(entry.Value.Name, ScriptBlock.EmptyScriptBlock, context); break; case CommandTypes.Filter: current = new FilterInfo(entry.Value.Name, ScriptBlock.EmptyScriptBlock, context); break; case CommandTypes.Configuration: current = new ConfigurationInfo(entry.Value.Name, ScriptBlock.EmptyScriptBlock, context); break; case CommandTypes.Cmdlet: current = new CmdletInfo(entry.Value.Name, implementingType: null, helpFile: null, PSSnapin: null, context); break; default: Dbg.Assert(false, "cannot be hit"); break; } current.Module = tempModuleInfo; yield return(current); } } continue; } } string moduleShortName = Path.GetFileNameWithoutExtension(modulePath); IDictionary <string, CommandTypes> exportedCommands = AnalysisCache.GetExportedCommands(modulePath, testOnly: false, context); if (exportedCommands == null) { continue; } tempModuleInfo = new PSModuleInfo(moduleShortName, modulePath, sessionState: null, context: null); if (InitialSessionState.IsEngineModule(moduleShortName)) { tempModuleInfo.SetModuleBase(Utils.DefaultPowerShellAppBase); } // moduleVersionRequired is bypassed by FullyQualifiedModule from calling method. This is the only place where guid will be involved. if (moduleVersionRequired && modulePath.EndsWith(StringLiterals.PowerShellDataFileExtension, StringComparison.OrdinalIgnoreCase)) { tempModuleInfo.SetVersion(ModuleIntrinsics.GetManifestModuleVersion(modulePath)); tempModuleInfo.SetGuid(ModuleIntrinsics.GetManifestGuid(modulePath)); } foreach (KeyValuePair <string, CommandTypes> pair in exportedCommands) { string commandName = pair.Key; CommandTypes commandTypes = pair.Value; if (commandPattern.IsMatch(commandName) || (useFuzzyMatching && FuzzyMatcher.IsFuzzyMatch(commandName, pattern)) || (useAbbreviationExpansion && string.Equals(pattern, AbbreviateName(commandName), StringComparison.OrdinalIgnoreCase))) { bool shouldExportCommand = true; // Verify that we don't already have it represented in the initial session state. if ((context.InitialSessionState != null) && (commandOrigin == CommandOrigin.Runspace)) { foreach (SessionStateCommandEntry commandEntry in context.InitialSessionState.Commands[commandName]) { string moduleCompareName = null; if (commandEntry.Module != null) { moduleCompareName = commandEntry.Module.Name; } else if (commandEntry.PSSnapIn != null) { moduleCompareName = commandEntry.PSSnapIn.Name; } if (string.Equals(moduleShortName, moduleCompareName, StringComparison.OrdinalIgnoreCase)) { if (commandEntry.Visibility == SessionStateEntryVisibility.Private) { shouldExportCommand = false; } } } } if (shouldExportCommand) { if ((commandTypes & CommandTypes.Alias) == CommandTypes.Alias) { yield return(new AliasInfo(commandName, null, context) { Module = tempModuleInfo }); } if ((commandTypes & CommandTypes.Cmdlet) == CommandTypes.Cmdlet) { yield return(new CmdletInfo(commandName, implementingType: null, helpFile: null, PSSnapin: null, context: context) { Module = tempModuleInfo }); } if ((commandTypes & CommandTypes.Function) == CommandTypes.Function) { yield return(new FunctionInfo(commandName, ScriptBlock.EmptyScriptBlock, context) { Module = tempModuleInfo }); } if ((commandTypes & CommandTypes.Configuration) == CommandTypes.Configuration) { yield return(new ConfigurationInfo(commandName, ScriptBlock.EmptyScriptBlock, context) { Module = tempModuleInfo }); } } } } } } }
public bool MoveNext() { try { int num = this.__1__state; if (num != 0) { if (num == 3) { this.__1__state = 2; this.__m__Finally1e(); } if (num == 7) { this.__1__state = 5; this.__m__Finally22(); } } else { this.__1__state = -1; this._commandPattern_5__b = new WildcardPattern(this.pattern, WildcardOptions.IgnoreCase); this._cmdletInfo_5__c = this.context.SessionState.InvokeCommand.GetCmdlet(@"Microsoft.PowerShell.Core\Get-Module"); aa__ = CommandDiscovery.GetCommandDiscoveryPreference(this.context, SpecialVariables.PSModuleAutoLoadingPreferenceVarPath, "PSModuleAutoLoadingPreference"); if ((aa__ != PSModuleAutoLoadingPreference.None) && ((this.commandOrigin == CommandOrigin.Internal) || ((this._cmdletInfo_5__c != null) && (this._cmdletInfo_5__c.Visibility == SessionStateEntryVisibility.Public)))) { this.__7__wrap1b = ModuleUtils.GetDefaultAvailableModuleFiles(true, false, this.context).GetEnumerator(); this.__1__state = 1; while (this.__7__wrap1b.MoveNext()) { this._modulePath_5__e = this.__7__wrap1b.Current; this._moduleName_5__f = Path.GetFileNameWithoutExtension(this._modulePath_5__e); this._modules_5__10 = this.context.Modules.GetExactMatchModules(this._moduleName_5__f, false, true); this._tempModuleInfo_5__11 = null; if (this._modules_5__10.Count != 0) { if (!this.rediscoverImportedModules) { continue; } if (this._modules_5__10.Exists(new Predicate <PSModuleInfo>(ModuleUtils.GetMatchingCommands_b__8))) { continue; } if (this._modules_5__10.Count == 1) { this._psModule_5__12 = this._modules_5__10[0]; this._tempModuleInfo_5__11 = new PSModuleInfo(this._psModule_5__12.Name, this._psModule_5__12.Path, null, null); this._tempModuleInfo_5__11.SetModuleBase(this._psModule_5__12.ModuleBase); this.__7__wrap1d = this._psModule_5__12.ExportedCommands.GetEnumerator(); this.__1__state = 2; while (this.__7__wrap1d.MoveNext()) { this._entry_5__13 = this.__7__wrap1d.Current; if (!this._commandPattern_5__b.IsMatch(this._entry_5__13.Value.Name)) { continue; } this._current_5__14 = null; switch (this._entry_5__13.Value.CommandType) { case CommandTypes.Alias: this._current_5__14 = new AliasInfo(this._entry_5__13.Value.Name, null, this.context); break; case CommandTypes.Function: this._current_5__14 = new FunctionInfo(this._entry_5__13.Value.Name, ScriptBlock.Create(""), this.context); break; case CommandTypes.Filter: this._current_5__14 = new FilterInfo(this._entry_5__13.Value.Name, ScriptBlock.Create(""), this.context); break; case CommandTypes.Cmdlet: this._current_5__14 = new CmdletInfo(this._entry_5__13.Value.Name, null, null, null, this.context); break; case CommandTypes.Workflow: this._current_5__14 = new WorkflowInfo(this._entry_5__13.Value.Name, ScriptBlock.Create(""), this.context); break; } this._current_5__14.SetModule(this._tempModuleInfo_5__11); this.__2__current = this._current_5__14; this.__1__state = 3; return(true); this.__1__state = 2; } this.__m__Finally1e(); continue; } } this._moduleShortName_5__15 = Path.GetFileNameWithoutExtension(this._modulePath_5__e); this._exportedCommands_5__16 = AnalysisCache.GetExportedCommands(this._modulePath_5__e, false, this.context); if (this._exportedCommands_5__16 != null) { this._tempModuleInfo_5__11 = new PSModuleInfo(this._moduleShortName_5__15, this._modulePath_5__e, null, null); if (InitialSessionState.IsEngineModule(this._moduleShortName_5__15)) { this._tempModuleInfo_5__11.SetModuleBase(Utils.GetApplicationBase(Utils.DefaultPowerShellShellID)); } this.__7__wrap1f = this._exportedCommands_5__16.Keys.GetEnumerator(); this.__1__state = 4; while (this.__7__wrap1f.MoveNext()) { this._exportedCommand_5__17 = this.__7__wrap1f.Current; if (this._commandPattern_5__b.IsMatch(this._exportedCommand_5__17)) { this.__7__wrap21 = this._exportedCommands_5__16[this._exportedCommand_5__17].GetEnumerator(); this.__1__state = 5; while (this.__7__wrap21.MoveNext()) { this._commandType_5__18 = this.__7__wrap21.Current; this._shouldExportCommand_5__19 = true; if ((this.context.InitialSessionState != null) && (this.commandOrigin == CommandOrigin.Runspace)) { foreach (SessionStateCommandEntry entry in this.context.InitialSessionState.Commands[this._exportedCommand_5__17]) { string b = null; if (entry.Module != null) { b = entry.Module.Name; } else if (entry.PSSnapIn != null) { b = entry.PSSnapIn.Name; } if (string.Equals(this._moduleShortName_5__15, b, StringComparison.OrdinalIgnoreCase) && (entry.Visibility == SessionStateEntryVisibility.Private)) { this._shouldExportCommand_5__19 = false; } } } if (!this._shouldExportCommand_5__19) { continue; } this._current_5__1a = null; switch (this._commandType_5__18) { case CommandTypes.Alias: this._current_5__1a = new AliasInfo(this._exportedCommand_5__17, null, this.context); break; case CommandTypes.Function: this._current_5__1a = new FunctionInfo(this._exportedCommand_5__17, ScriptBlock.Create(""), this.context); break; case CommandTypes.Cmdlet: this._current_5__1a = new CmdletInfo(this._exportedCommand_5__17, null, null, null, this.context); break; case CommandTypes.Workflow: this._current_5__1a = new WorkflowInfo(this._exportedCommand_5__17, ScriptBlock.Create(""), this.context); break; } if (this._current_5__1a != null) { this._current_5__1a.SetModule(this._tempModuleInfo_5__11); } this.__2__current = this._current_5__1a; this.__1__state = 7; return(true); Label_060F: this.__1__state = 5; } this.__m__Finally22(); } } this.__m__Finally20(); } } this.__m__Finally1c(); } } return(false); } finally { (this as IDisposable).Dispose(); } }
internal override bool ProcessModuleWithCulture(UpdatableHelpModuleInfo module, string culture) { if (((InitialSessionState.IsEngineModule(module.ModuleName) || InitialSessionState.IsNestedEngineModule(module.ModuleName)) || module.ModuleName.Equals(InitialSessionState.CoreSnapin, StringComparison.OrdinalIgnoreCase)) && !UpdatableHelpSystem.IsAdministrator()) { string message = StringUtil.Format(HelpErrors.UpdatableHelpRequiresElevation, new object[0]); base.ProcessException(module.ModuleName, null, new UpdatableHelpSystemException("UpdatableHelpSystemRequiresElevation", message, ErrorCategory.InvalidOperation, null, null)); return(false); } UpdatableHelpInfo currentHelpInfo = null; UpdatableHelpInfo newHelpInfo = null; string str2 = null; string xml = UpdatableHelpSystem.LoadStringFromPath(this, base.SessionState.Path.Combine(module.ModuleBase, module.GetHelpInfoName()), null); if (xml != null) { currentHelpInfo = base._helpSystem.CreateHelpInfo(xml, module.ModuleName, module.ModuleGuid, null, null, false); } if (!this.alreadyCheckedOncePerDayPerModule && !base.CheckOncePerDayPerModule(module.ModuleName, module.ModuleBase, module.GetHelpInfoName(), DateTime.UtcNow, base._force)) { return(true); } this.alreadyCheckedOncePerDayPerModule = true; if (this._path != null) { //using (null) { try { Collection <string> collection = new Collection <string>(); foreach (string str4 in this._path) { if (string.IsNullOrEmpty(str4)) { PSArgumentException exception = new PSArgumentException(StringUtil.Format(HelpDisplayStrings.PathNullOrEmpty, new object[0])); base.WriteError(exception.ErrorRecord); return(false); } try { string path = str4; if (base._credential != null) { UpdatableHelpSystemDrive drive2 = new UpdatableHelpSystemDrive(this, str4, base._credential); path = drive2.DriveName; } foreach (string str6 in base.ResolvePath(path, this._recurse, this.isLiteralPath)) { collection.Add(str6); } } catch (System.Management.Automation.DriveNotFoundException exception2) { this.ThrowPathMustBeValidContainersException(str4, exception2); } catch (ItemNotFoundException exception3) { this.ThrowPathMustBeValidContainersException(str4, exception3); } } if (collection.Count == 0) { return(true); } foreach (string str7 in collection) { string str8 = base.SessionState.Path.Combine(str7, module.GetHelpInfoName()); xml = UpdatableHelpSystem.LoadStringFromPath(this, str8, base._credential); if (xml != null) { newHelpInfo = base._helpSystem.CreateHelpInfo(xml, module.ModuleName, module.ModuleGuid, culture, str7, false); str2 = str7; goto Label_02DD; } } } catch (Exception exception4) { CommandProcessorBase.CheckForSevereException(exception4); throw new UpdatableHelpSystemException("UnableToRetrieveHelpInfoXml", StringUtil.Format(HelpDisplayStrings.UnableToRetrieveHelpInfoXml, culture), ErrorCategory.ResourceUnavailable, null, exception4); } goto Label_02DD; } } string str9 = base._helpSystem.GetHelpInfoUri(module, null).ResolvedUri + module.GetHelpInfoName(); newHelpInfo = base._helpSystem.GetHelpInfo(UpdatableHelpCommandType.UpdateHelpCommand, str9, module.ModuleName, module.ModuleGuid, culture); Label_02DD: if (newHelpInfo == null) { throw new UpdatableHelpSystemException("UnableToRetrieveHelpInfoXml", StringUtil.Format(HelpDisplayStrings.UnableToRetrieveHelpInfoXml, culture), ErrorCategory.ResourceUnavailable, null, null); } bool flag = false; foreach (UpdatableHelpUri uri in newHelpInfo.HelpContentUriCollection) { if (!base.IsUpdateNecessary(module, currentHelpInfo, newHelpInfo, uri.Culture, base._force)) { base.WriteVerbose(StringUtil.Format(HelpDisplayStrings.SuccessfullyUpdatedHelpContent, new object[] { module.ModuleName, HelpDisplayStrings.NewestContentAlreadyInstalled, uri.Culture.Name, newHelpInfo.GetCultureVersion(uri.Culture) })); flag = true; } else { try { Collection <string> collection3; string resolvedUri = uri.ResolvedUri; string xsdPath = base.SessionState.Path.Combine(Utils.GetApplicationBase(base.Context.ShellID), @"Schemas\PSMaml\maml.xsd"); Collection <string> destPaths = new Collection <string> { module.ModuleBase }; if (UpdatableHelpCommandBase.IsSystemModule(module.ModuleName) && Environment.Is64BitOperatingSystem) { string item = Utils.GetApplicationBase(Utils.DefaultPowerShellShellID).Replace("System32", "SysWOW64"); destPaths.Add(item); } if (Directory.Exists(resolvedUri)) { if (base._credential != null) { string helpContentName = module.GetHelpContentName(uri.Culture); string str14 = Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(Path.GetRandomFileName())); try { using (UpdatableHelpSystemDrive drive3 = new UpdatableHelpSystemDrive(this, resolvedUri, base._credential)) { if (!Directory.Exists(str14)) { Directory.CreateDirectory(str14); } base.InvokeProvider.Item.Copy(new string[] { Path.Combine(drive3.DriveName, helpContentName) }, Path.Combine(str14, helpContentName), false, CopyContainers.CopyTargetContainer, true, true); base._helpSystem.InstallHelpContent(UpdatableHelpCommandType.UpdateHelpCommand, base.Context, str14, destPaths, module.GetHelpContentName(uri.Culture), Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(Path.GetRandomFileName())), uri.Culture, xsdPath, out collection3); } goto Label_0593; } catch (Exception exception5) { CommandProcessorBase.CheckForSevereException(exception5); throw new UpdatableHelpSystemException("HelpContentNotFound", StringUtil.Format(HelpDisplayStrings.HelpContentNotFound, new object[0]), ErrorCategory.ResourceUnavailable, null, exception5); } } base._helpSystem.InstallHelpContent(UpdatableHelpCommandType.UpdateHelpCommand, base.Context, resolvedUri, destPaths, module.GetHelpContentName(uri.Culture), Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(Path.GetRandomFileName())), uri.Culture, xsdPath, out collection3); } else if (!base._helpSystem.DownloadAndInstallHelpContent(UpdatableHelpCommandType.UpdateHelpCommand, base.Context, destPaths, module.GetHelpContentName(uri.Culture), uri.Culture, resolvedUri, xsdPath, out collection3)) { flag = false; goto Label_069B; } Label_0593: base._helpSystem.GenerateHelpInfo(module.ModuleName, module.ModuleGuid, newHelpInfo.UnresolvedUri, uri.Culture.Name, newHelpInfo.GetCultureVersion(uri.Culture), module.ModuleBase, module.GetHelpInfoName(), base._force); foreach (string str15 in collection3) { base.WriteVerbose(StringUtil.Format(HelpDisplayStrings.SuccessfullyUpdatedHelpContent, new object[] { module.ModuleName, StringUtil.Format(HelpDisplayStrings.UpdatedHelpContent, str15), uri.Culture.Name, newHelpInfo.GetCultureVersion(uri.Culture) })); } base.LogMessage(StringUtil.Format(HelpDisplayStrings.UpdateHelpCompleted, new object[0])); flag = true; } catch (Exception exception6) { CommandProcessorBase.CheckForSevereException(exception6); base.ProcessException(module.ModuleName, uri.Culture.Name, exception6); } Label_069B :; } } return(flag); }
protected override void ProcessRecord() { Dictionary <PSModuleInfo, List <PSModuleInfo> > dictionary = new Dictionary <PSModuleInfo, List <PSModuleInfo> >(); foreach (PSModuleInfo info in base.Context.Modules.GetModules(this._name, false)) { dictionary.Add(info, new List <PSModuleInfo> { info }); } foreach (PSModuleInfo info2 in this._moduleInfo) { dictionary.Add(info2, new List <PSModuleInfo> { info2 }); } Dictionary <PSModuleInfo, List <PSModuleInfo> > dictionary2 = new Dictionary <PSModuleInfo, List <PSModuleInfo> >(); foreach (KeyValuePair <PSModuleInfo, List <PSModuleInfo> > pair in dictionary) { PSModuleInfo key = pair.Key; if ((key.NestedModules != null) && (key.NestedModules.Count > 0)) { List <PSModuleInfo> nestedModulesWithNoCircularReference = new List <PSModuleInfo>(); this.GetAllNestedModules(key, ref nestedModulesWithNoCircularReference); dictionary2.Add(key, nestedModulesWithNoCircularReference); } } HashSet <PSModuleInfo> set = new HashSet <PSModuleInfo>(new PSModuleInfoComparer()); if (dictionary2.Count > 0) { foreach (KeyValuePair <PSModuleInfo, List <PSModuleInfo> > pair2 in dictionary2) { List <PSModuleInfo> list4 = null; if (dictionary.TryGetValue(pair2.Key, out list4)) { foreach (PSModuleInfo info4 in pair2.Value) { if (!set.Contains(info4)) { list4.Add(info4); set.Add(info4); } } } } } Dictionary <PSModuleInfo, List <PSModuleInfo> > dictionary3 = new Dictionary <PSModuleInfo, List <PSModuleInfo> >(); foreach (KeyValuePair <PSModuleInfo, List <PSModuleInfo> > pair3 in dictionary) { List <PSModuleInfo> list5 = new List <PSModuleInfo>(); for (int i = pair3.Value.Count - 1; i >= 0; i--) { PSModuleInfo targetObject = pair3.Value[i]; if (targetObject.AccessMode == ModuleAccessMode.Constant) { InvalidOperationException exception = new InvalidOperationException(StringUtil.Format(Modules.ModuleIsConstant, targetObject.Name)); ErrorRecord errorRecord = new ErrorRecord(exception, "Modules_ModuleIsConstant", ErrorCategory.PermissionDenied, targetObject); base.WriteError(errorRecord); } else if ((targetObject.AccessMode == ModuleAccessMode.ReadOnly) && !base.BaseForce) { string text = StringUtil.Format(Modules.ModuleIsReadOnly, targetObject.Name); if (InitialSessionState.IsConstantEngineModule(targetObject.Name)) { base.WriteWarning(text); } else { InvalidOperationException exception2 = new InvalidOperationException(text); ErrorRecord record2 = new ErrorRecord(exception2, "Modules_ModuleIsReadOnly", ErrorCategory.PermissionDenied, targetObject); base.WriteError(record2); } } else if (base.ShouldProcess(StringUtil.Format(Modules.ConfirmRemoveModule, targetObject.Name, targetObject.Path))) { if (this.ModuleProvidesCurrentSessionDrive(targetObject)) { if (!InitialSessionState.IsEngineModule(targetObject.Name)) { string str4 = (this._name.Length == 1) ? this._name[0] : targetObject.Name; throw PSTraceSource.NewInvalidOperationException("Modules", "ModuleDriveInUse", new object[] { str4 }); } if (!base.BaseForce) { string str3 = StringUtil.Format(Modules.CoreModuleCannotBeRemoved, targetObject.Name); base.WriteWarning(str3); } } else { list5.Add(targetObject); } } } dictionary3[pair3.Key] = list5; } Dictionary <PSModuleInfo, List <PSModuleInfo> > requiredDependencies = this.GetRequiredDependencies(); foreach (KeyValuePair <PSModuleInfo, List <PSModuleInfo> > pair4 in dictionary3) { foreach (PSModuleInfo info6 in pair4.Value) { if (!base.BaseForce) { List <PSModuleInfo> list6 = null; if (requiredDependencies.TryGetValue(info6, out list6)) { for (int j = list6.Count - 1; j >= 0; j--) { if (dictionary3.ContainsKey(list6[j])) { list6.RemoveAt(j); } } if (list6.Count > 0) { InvalidOperationException exception4 = new InvalidOperationException(StringUtil.Format(Modules.ModuleIsRequired, info6.Name, list6[0].Name)); ErrorRecord record3 = new ErrorRecord(exception4, "Modules_ModuleIsRequired", ErrorCategory.PermissionDenied, info6); base.WriteError(record3); continue; } } } this._numberRemoved++; base.RemoveModule(info6, pair4.Key.Name); } } }
private Dictionary <string, UpdatableHelpModuleInfo> GetModuleInfo(System.Management.Automation.ExecutionContext context, string pattern, bool loaded, bool noErrors) { List <PSModuleInfo> modules = context.Modules.GetModules(new string[] { pattern }, false); Dictionary <string, UpdatableHelpModuleInfo> dictionary = new Dictionary <string, UpdatableHelpModuleInfo>(); if (modules.Count != 0) { base.WriteDebug(StringUtil.Format("Found {0} loaded modules.", modules.Count)); foreach (PSModuleInfo info in modules) { if (InitialSessionState.IsEngineModule(info.Name) && !InitialSessionState.IsNestedEngineModule(info.Name)) { base.WriteDebug(StringUtil.Format("Found engine module: {0}, {1}.", info.Name, info.Guid)); if (!dictionary.ContainsKey(info.Name)) { dictionary.Add(info.Name, new UpdatableHelpModuleInfo(info.Name, info.Guid, Utils.GetApplicationBase(context.ShellID), metadataCache[info.Name])); } } else if (!InitialSessionState.IsNestedEngineModule(info.Name)) { if (string.IsNullOrEmpty(info.HelpInfoUri)) { if (!noErrors) { this.ProcessException(info.Name, null, new UpdatableHelpSystemException("HelpInfoUriNotFound", StringUtil.Format(HelpDisplayStrings.HelpInfoUriNotFound, new object[0]), ErrorCategory.NotSpecified, new Uri("HelpInfoUri", UriKind.Relative), null)); } } else if (!info.HelpInfoUri.StartsWith("http://", StringComparison.OrdinalIgnoreCase)) { if (!noErrors) { this.ProcessException(info.Name, null, new UpdatableHelpSystemException("InvalidHelpInfoUriFormat", StringUtil.Format(HelpDisplayStrings.InvalidHelpInfoUriFormat, info.HelpInfoUri), ErrorCategory.NotSpecified, new Uri("HelpInfoUri", UriKind.Relative), null)); } } else if (!dictionary.ContainsKey(info.Name)) { dictionary.Add(info.Name, new UpdatableHelpModuleInfo(info.Name, info.Guid, info.ModuleBase, info.HelpInfoUri)); } } } } WildcardOptions options = WildcardOptions.CultureInvariant | WildcardOptions.IgnoreCase; IEnumerable <WildcardPattern> patterns = SessionStateUtilities.CreateWildcardsFromStrings(new string[] { pattern }, options); if (!loaded) { Collection <PSObject> collection = base.InvokeCommand.InvokeScript("Get-Module -ListAvailable"); Collection <PSModuleInfo> collection2 = new Collection <PSModuleInfo>(); if (collection != null) { foreach (PSObject obj2 in collection) { try { collection2.Add((PSModuleInfo)LanguagePrimitives.ConvertTo(obj2, typeof(PSModuleInfo), CultureInfo.InvariantCulture)); } catch (PSInvalidCastException) { } } } base.WriteDebug(StringUtil.Format("Found {0} available (Get-Module -ListAvailable) modules.", collection2.Count)); foreach (PSModuleInfo info2 in collection2) { if (SessionStateUtilities.MatchesAnyWildcardPattern(info2.Name, patterns, true)) { if (InitialSessionState.IsEngineModule(info2.Name) && !InitialSessionState.IsNestedEngineModule(info2.Name)) { base.WriteDebug(StringUtil.Format("Found engine module: {0}, {1}.", info2.Name, info2.Guid)); if (!dictionary.ContainsKey(info2.Name)) { dictionary.Add(info2.Name, new UpdatableHelpModuleInfo(info2.Name, info2.Guid, Utils.GetApplicationBase(context.ShellID), metadataCache[info2.Name])); } } else if (!InitialSessionState.IsNestedEngineModule(info2.Name)) { if (string.IsNullOrEmpty(info2.HelpInfoUri)) { if (!noErrors) { this.ProcessException(info2.Name, null, new UpdatableHelpSystemException("HelpInfoUriNotFound", StringUtil.Format(HelpDisplayStrings.HelpInfoUriNotFound, new object[0]), ErrorCategory.NotSpecified, new Uri("HelpInfoUri", UriKind.Relative), null)); } } else if (!info2.HelpInfoUri.StartsWith("http://", StringComparison.OrdinalIgnoreCase)) { if (!noErrors) { this.ProcessException(info2.Name, null, new UpdatableHelpSystemException("InvalidHelpInfoUriFormat", StringUtil.Format(HelpDisplayStrings.InvalidHelpInfoUriFormat, info2.HelpInfoUri), ErrorCategory.NotSpecified, new Uri("HelpInfoUri", UriKind.Relative), null)); } } else if (!dictionary.ContainsKey(info2.Name)) { dictionary.Add(info2.Name, new UpdatableHelpModuleInfo(info2.Name, info2.Guid, info2.ModuleBase, info2.HelpInfoUri)); } } } } } foreach (KeyValuePair <string, string> pair in metadataCache) { if (SessionStateUtilities.MatchesAnyWildcardPattern(pair.Key, patterns, true)) { if (!pair.Key.Equals(InitialSessionState.CoreSnapin, StringComparison.OrdinalIgnoreCase)) { Collection <PSObject> collection3 = base.InvokeCommand.InvokeScript(StringUtil.Format("Get-Module {0} -ListAvailable", pair.Key)); Collection <PSModuleInfo> collection4 = new Collection <PSModuleInfo>(); if (collection3 != null) { foreach (PSObject obj3 in collection3) { try { collection4.Add((PSModuleInfo)LanguagePrimitives.ConvertTo(obj3, typeof(PSModuleInfo), CultureInfo.InvariantCulture)); } catch (PSInvalidCastException) { } } } foreach (PSModuleInfo info3 in collection4) { if (!dictionary.ContainsKey(info3.Name)) { base.WriteDebug(StringUtil.Format("Found engine module: {0}, {1}.", info3.Name, info3.Guid)); dictionary.Add(pair.Key, new UpdatableHelpModuleInfo(info3.Name, info3.Guid, Utils.GetApplicationBase(context.ShellID), metadataCache[info3.Name])); } } } else if (!dictionary.ContainsKey(pair.Key)) { dictionary.Add(pair.Key, new UpdatableHelpModuleInfo(pair.Key, Guid.Empty, Utils.GetApplicationBase(context.ShellID), pair.Value)); } } } return(dictionary); }
/// <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); } } }
private void AddPSSnapIns(Collection <string> snapInList) { if (snapInList != null) { if (base.Context.RunspaceConfiguration == null) { Collection <PSSnapInInfo> snapIns = base.GetSnapIns(null); InitialSessionState state = InitialSessionState.Create(); bool flag = false; foreach (string str in snapInList) { if (InitialSessionState.IsEngineModule(str)) { base.WriteNonTerminatingError(str, "LoadSystemSnapinAsModule", PSTraceSource.NewArgumentException(str, "MshSnapInCmdletResources", "LoadSystemSnapinAsModule", new object[] { str }), ErrorCategory.InvalidArgument); } else { try { PSSnapInInfo psSnapInInfo = PSSnapInReader.Read(Utils.GetCurrentMajorVersion(), str); PSSnapInInfo info2 = PSSnapInCommandBase.IsSnapInLoaded(snapIns, psSnapInInfo); if (info2 == null) { PSSnapInException exception; info2 = state.ImportPSSnapIn(str, out exception); flag = true; base.Context.InitialSessionState.ImportedSnapins.Add(info2.Name, info2); } if (this._passThru) { info2.LoadIndirectResources(base.ResourceReader); base.WriteObject(info2); } } catch (PSSnapInException exception2) { base.WriteNonTerminatingError(str, "AddPSSnapInRead", exception2, ErrorCategory.InvalidData); } } } if (flag) { state.Bind(base.Context, true); } } else { foreach (string str2 in snapInList) { Exception innerException = null; try { PSSnapInException warning = null; PSSnapInInfo sendToPipeline = base.Runspace.AddPSSnapIn(str2, out warning); if (warning != null) { base.WriteNonTerminatingError(str2, "AddPSSnapInRead", warning, ErrorCategory.InvalidData); } if (this._passThru) { sendToPipeline.LoadIndirectResources(base.ResourceReader); base.WriteObject(sendToPipeline); } } catch (PSArgumentException exception5) { innerException = exception5; } catch (PSSnapInException exception6) { innerException = exception6; } catch (SecurityException exception7) { innerException = exception7; } if (innerException != null) { base.WriteNonTerminatingError(str2, "AddPSSnapInRead", innerException, ErrorCategory.InvalidArgument); } } } } }