/// <summary> /// Resets <see cref="GraphSession"/> instance when a user removes the module from the session via Remove-Module. /// </summary> /// <param name="psModuleInfo">A <see cref="PSModuleInfo"/> object.</param> public void OnRemove(PSModuleInfo psModuleInfo) { GraphSession.Reset(); }
/// <summary> /// Take module info of module that can be already loaded or not and loads it. /// </summary> /// <param name="originalModuleInfo"></param> /// <returns>module info of the same module, but loaded</returns> private static PSModuleInfo LoadModule(PSModuleInfo originalModuleInfo) { // originalModuleInfo is created during parse time and may not contain [System.Type] types exported from the module. // At this moment, we need to actually load the module and create types. // We want to load **exactly the same module** as we used at parse time. // And avoid the module resolution logic that can lead to another module (if something changed on the file system). // So, we load the module by the file path, not by module specification (ModuleName, RequiredVersion). var modulePath = originalModuleInfo.Path; var commandInfo = new CmdletInfo("Import-Module", typeof(ImportModuleCommand)); var ps = PowerShell.Create(RunspaceMode.CurrentRunspace) .AddCommand(commandInfo) .AddParameter("Name", modulePath) .AddParameter("PassThru"); var moduleInfo = ps.Invoke<PSModuleInfo>(); if (ps.HadErrors) { var errorRecord = ps.Streams.Error[0]; throw InterpreterError.NewInterpreterException(modulePath, typeof(RuntimeException), null, errorRecord.FullyQualifiedErrorId, errorRecord.ToString()); } if (moduleInfo.Count == 1) { return moduleInfo[0]; } else { Diagnostics.Assert(false, "We should load exactly one module from the provided original module"); return null; } }
/// <summary> /// Add Type from the different module to the symbol Table. /// </summary> /// <param name="typeDefinitionAst"></param> /// <param name="moduleInfo"></param> public void AddTypeFromUsingModule(TypeDefinitionAst typeDefinitionAst, PSModuleInfo moduleInfo) { _scopes[_scopes.Count - 1].AddTypeFromUsingModule(_parser, typeDefinitionAst, moduleInfo); }
/// <summary> /// Resets <see cref="GraphSession"/> instance when a user removes the module from the session via Remove-Module. /// </summary> /// <param name="psModuleInfo">A <see cref="PSModuleInfo"/> object.</param> public void OnRemove(PSModuleInfo psModuleInfo) { GraphSession.Reset(); DependencyAssemblyResolver.Reset(); }
public PowerShellModule(PSModuleInfo module) { Name = module.Name ?? string.Empty; }
internal static void AnalyzePSSnapInAssembly(Assembly assembly, string name, PSSnapInInfo psSnapInInfo, PSModuleInfo moduleInfo, bool isModuleLoad, out Dictionary <string, SessionStateCmdletEntry> cmdlets, out Dictionary <string, SessionStateProviderEntry> providers, out string helpFile) { Type[] assemblyTypes; helpFile = null; if (assembly == null) { throw new ArgumentNullException("assembly"); } cmdlets = null; providers = null; if (_cmdletCache.Value.ContainsKey(assembly)) { cmdlets = new Dictionary <string, SessionStateCmdletEntry>(_cmdletCache.Value.Count, StringComparer.OrdinalIgnoreCase); Dictionary <string, SessionStateCmdletEntry> dictionary = _cmdletCache.Value[assembly]; foreach (string str in dictionary.Keys) { SessionStateCmdletEntry entry = dictionary[str]; if ((entry.PSSnapIn == null) && (psSnapInInfo != null)) { entry.SetPSSnapIn(psSnapInInfo); } SessionStateCmdletEntry entry2 = (SessionStateCmdletEntry)entry.Clone(); cmdlets[str] = entry2; } } if (_providerCache.Value.ContainsKey(assembly)) { providers = new Dictionary <string, SessionStateProviderEntry>(_providerCache.Value.Count, StringComparer.OrdinalIgnoreCase); Dictionary <string, SessionStateProviderEntry> dictionary2 = _providerCache.Value[assembly]; foreach (string str2 in dictionary2.Keys) { SessionStateProviderEntry entry3 = dictionary2[str2]; if ((entry3.PSSnapIn == null) && (psSnapInInfo != null)) { entry3.SetPSSnapIn(psSnapInInfo); } SessionStateProviderEntry entry4 = (SessionStateProviderEntry)entry3.Clone(); providers[str2] = entry4; } } if ((cmdlets != null) || (providers != null)) { if (!_assembliesWithModuleInitializerCache.Value.ContainsKey(assembly)) { _PSSnapInTracer.WriteLine("Returning cached cmdlet and provider entries for {0}", new object[] { assembly.Location }); } else { _PSSnapInTracer.WriteLine("Executing IModuleAssemblyInitializer.Import for {0}", new object[] { assembly.Location }); assemblyTypes = GetAssemblyTypes(assembly, name); ExecuteModuleInitializer(assembly, assemblyTypes, isModuleLoad); } } else { _PSSnapInTracer.WriteLine("Analyzing assembly {0} for cmdlet and providers", new object[] { assembly.Location }); helpFile = GetHelpFile(assembly.Location); assemblyTypes = GetAssemblyTypes(assembly, name); ExecuteModuleInitializer(assembly, assemblyTypes, isModuleLoad); Type type = null; Type type2 = null; foreach (Type type3 in assemblyTypes) { if ((type3.IsPublic || type3.IsNestedPublic) && !type3.IsAbstract) { if (IsCmdletClass(type3) && HasDefaultConstructor(type3)) { type = type3; CmdletAttribute customAttribute = GetCustomAttribute <CmdletAttribute>(type3); if (customAttribute != null) { string cmdletName = GetCmdletName(customAttribute); if (!string.IsNullOrEmpty(cmdletName)) { if ((cmdlets != null) && cmdlets.ContainsKey(cmdletName)) { string errorMessageFormat = StringUtil.Format(ConsoleInfoErrorStrings.PSSnapInDuplicateCmdlets, cmdletName, name); _PSSnapInTracer.TraceError(errorMessageFormat, new object[0]); throw new PSSnapInException(name, errorMessageFormat); } SessionStateCmdletEntry entry5 = new SessionStateCmdletEntry(cmdletName, type3, helpFile); if (psSnapInInfo != null) { entry5.SetPSSnapIn(psSnapInInfo); } if (cmdlets == null) { cmdlets = new Dictionary <string, SessionStateCmdletEntry>(StringComparer.OrdinalIgnoreCase); } cmdlets.Add(cmdletName, entry5); _PSSnapInTracer.WriteLine("{0} from type {1} is added as a cmdlet. ", new object[] { cmdletName, type3.FullName }); } } } else if (IsProviderClass(type3) && HasDefaultConstructor(type3)) { type2 = type3; CmdletProviderAttribute providerAttribute = GetCustomAttribute <CmdletProviderAttribute>(type3); if (providerAttribute != null) { string providerName = GetProviderName(providerAttribute); if (!string.IsNullOrEmpty(providerName)) { if ((providers != null) && providers.ContainsKey(providerName)) { string str6 = StringUtil.Format(ConsoleInfoErrorStrings.PSSnapInDuplicateProviders, providerName, psSnapInInfo.Name); _PSSnapInTracer.TraceError(str6, new object[0]); throw new PSSnapInException(psSnapInInfo.Name, str6); } SessionStateProviderEntry entry6 = new SessionStateProviderEntry(providerName, type3, helpFile); entry6.SetPSSnapIn(psSnapInInfo); if (moduleInfo != null) { entry6.SetModule(moduleInfo); } if (providers == null) { providers = new Dictionary <string, SessionStateProviderEntry>(StringComparer.OrdinalIgnoreCase); } providers.Add(providerName, entry6); _PSSnapInTracer.WriteLine("{0} from type {1} is added as a provider. ", new object[] { providerName, type3.FullName }); } } } } } if (((providers == null) || (providers.Count == 0)) && ((cmdlets == null) || (cmdlets.Count == 0))) { try { if (type != null) { ConstructorInfo constructor = type.GetConstructor(Type.EmptyTypes); if (constructor != null) { constructor.Invoke(null); } } if (type2 != null) { ConstructorInfo info2 = type2.GetConstructor(Type.EmptyTypes); if (info2 != null) { info2.Invoke(null); } } } catch (TargetInvocationException exception) { throw exception.InnerException; } } if (cmdlets != null) { Dictionary <string, SessionStateCmdletEntry> dictionary3 = new Dictionary <string, SessionStateCmdletEntry>(cmdlets.Count, StringComparer.OrdinalIgnoreCase); foreach (KeyValuePair <string, SessionStateCmdletEntry> pair in cmdlets) { dictionary3[pair.Key] = (SessionStateCmdletEntry)pair.Value.Clone(); } _cmdletCache.Value[assembly] = dictionary3; } if (providers != null) { Dictionary <string, SessionStateProviderEntry> dictionary4 = new Dictionary <string, SessionStateProviderEntry>(providers.Count, StringComparer.OrdinalIgnoreCase); foreach (KeyValuePair <string, SessionStateProviderEntry> pair2 in providers) { dictionary4[pair2.Key] = (SessionStateProviderEntry)pair2.Value.Clone(); } _providerCache.Value[assembly] = providers; } } }
public void OnRemove(PSModuleInfo psModuleInfo) { AppDomain.CurrentDomain.AssemblyResolve -= HandleAssemblyResolve; }
/// <summary> /// Generates a complete activity source file from a module. /// </summary> /// <param name="moduleToProcess"></param> /// <param name="activityNamespace">The namespace to use for the target classes</param> /// <returns>An array of code elements to compile into an assembly</returns> static public string[] GenerateFromModuleInfo(PSModuleInfo moduleToProcess, string activityNamespace) { if (moduleToProcess == null) { throw new ArgumentNullException("moduleToProcess"); } List <string> codeToCompile = new List <string>(); // Cmdlets and function need to exist in separate namespaces... if (moduleToProcess.ExportedCmdlets != null) { string namespaceToUse = !string.IsNullOrEmpty(activityNamespace) ? activityNamespace : moduleToProcess.Name + "_Cmdlet_Activities"; foreach (CmdletInfo ci in moduleToProcess.ExportedCmdlets.Values) { string code = Microsoft.PowerShell.Activities.ActivityGenerator.GenerateFromCommandInfo(ci, namespaceToUse, "PSRemotingActivity", null, null, ""); codeToCompile.Add(code); } } Dictionary <string, string> modules = new Dictionary <string, string>(); PSModuleInfo cimModule = moduleToProcess; if (moduleToProcess.ExportedFunctions != null) { string namespaceToUse = !string.IsNullOrEmpty(activityNamespace) ? activityNamespace : moduleToProcess.Name + "_Function_Activities"; foreach (FunctionInfo fi in moduleToProcess.ExportedFunctions.Values) { string moduleName = null; string moduleDefinition = null; // Save the module defining this function - we may need to extract // embedded types further on if (fi.ScriptBlock.Module != null && !string.IsNullOrEmpty(fi.ScriptBlock.Module.Definition)) { moduleName = fi.ScriptBlock.Module.Name; moduleDefinition = fi.ScriptBlock.Module.Definition; } string code; if (fi.ScriptBlock.Module.ModuleType == ModuleType.Cim) { // Special-case CIM activities string embeddedDefinition = ""; // Embed the module definition in the activity... if (moduleDefinition != null) { // Remove all of the calls to Export-ModuleMember and getcommand string editedDefinition = System.Text.RegularExpressions.Regex.Replace(moduleDefinition, @"Microsoft.PowerShell.Core\\Export-ModuleMember[^\n]*\n", ""); editedDefinition = System.Text.RegularExpressions.Regex.Replace(editedDefinition, @"if \(\$\(Microsoft.PowerShell.Core\\Get-Command Set-StrictMode[^\n]*\n", ""); embeddedDefinition = "protected override string ModuleDefinition { get { return _moduleDefinition; } }\r\n const string _moduleDefinition = @\"" + editedDefinition.Replace("\"", "\"\"") + "\";"; } code = Microsoft.PowerShell.Activities.ActivityGenerator.GenerateFromCommandInfo( fi, namespaceToUse, "PSGeneratedCIMActivity", new string[] { "Computer", "AsJob", "CimSession" }, null, embeddedDefinition); cimModule = fi.ScriptBlock.Module; } else { code = Microsoft.PowerShell.Activities.ActivityGenerator.GenerateFromCommandInfo( fi, namespaceToUse, "PSRemotingActivity", new string[] { "Computer", "AsJob" }, moduleToProcess.Name, ""); } codeToCompile.Add(code); if (moduleName != null && !modules.ContainsKey(fi.ScriptBlock.Module.Name)) { modules.Add(moduleName, moduleDefinition); } } } string fileName = cimModule.Path; // See if there are any embedded types to extract if (Path.GetExtension(fileName).Equals(".cdxml", StringComparison.OrdinalIgnoreCase)) { // generate cmdletization proxies using (FileStream file = new FileStream(fileName, FileMode.Open, FileAccess.Read)) { XmlReader xmlReader = XmlReader.Create(file, xmlReaderSettings.Value); PowerShellMetadata cmdletizationMetadata = (PowerShellMetadata)xmlSerializer.Value.Deserialize(xmlReader); if (cmdletizationMetadata != null && cmdletizationMetadata.Enums != null) { foreach (EnumMetadataEnum enumMetadata in cmdletizationMetadata.Enums) { codeToCompile.Add(GetCSharpCode(enumMetadata)); } } } } return(codeToCompile.ToArray <string>()); }
/// <summary> /// Loads and retrieves information about a given module. /// </summary> /// <param name="module">The module to load, given as a PSModuleInfo.</param> /// <param name="error">Any error encountered, if any.</param> /// <returns>The name, version and data object for the module, or null if data collection did not succeed.</returns> public Tuple <string, Version, ModuleData> LoadAndGetModuleData(PSModuleInfo module, out Exception error) { try { PSModuleInfo importedModule = _pwsh.AddCommand(s_ipmoInfo) .AddParameter("ModuleInfo", module) .AddParameter("PassThru") .AddParameter("ErrorAction", "Stop") .InvokeAndClear <PSModuleInfo>() .FirstOrDefault(); if (importedModule == null) { error = null; return(null); } Tuple <string, Version, ModuleData> moduleData = GetSingleModuleData(importedModule); _pwsh.AddCommand(s_rmoInfo) .AddParameter("ModuleInfo", importedModule) .InvokeAndClear(); error = null; return(moduleData); } catch (RuntimeException e) { // A common problem is TypeData being hit with other modules, this overrides that if (e.ErrorRecord.FullyQualifiedErrorId.Equals("FormatXmlUpdateException,Microsoft.PowerShell.Commands.ImportModuleCommand") || e.ErrorRecord.FullyQualifiedErrorId.Equals("ErrorsUpdatingTypes")) { foreach (string typeDataName in GetTypeDataNamesFromErrorMessage(e.Message)) { _pwsh.AddCommand("Remove-TypeData") .AddParameter("TypeName", typeDataName) .InvokeAndClear(); } } // Attempt to load the module in a new runspace instead try { using (SMA.PowerShell fallbackPwsh = SMA.PowerShell.Create(RunspaceMode.NewRunspace)) { PSModuleInfo importedModule = fallbackPwsh.AddCommand(s_ipmoInfo) .AddParameter("Name", module.Path) .AddParameter("PassThru") .AddParameter("Force") .AddParameter("ErrorAction", "Stop") .InvokeAndClear <PSModuleInfo>() .FirstOrDefault(); error = null; return(GetSingleModuleData(importedModule)); } } catch (Exception fallbackException) { error = fallbackException; return(null); } } }
private IEnumerable <KeyValuePair <string, string> > GetPackageManagementModules(PSModuleInfo module) { // skip modules that we know don't contain any PM modules if (!_exclusionList.Contains(module.Name)) { var privateData = module.PrivateData as Hashtable; if (privateData != null) { return(ScanPrivateDataForProviders(Path.GetDirectoryName(module.Path), privateData, module.Version)); } } return(Enumerable.Empty <KeyValuePair <string, string> >()); }
public PowerShellPackageProvider(DynamicPowershell ps, PSModuleInfo module) : base(ps, module) { }
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) { // TODO: // Paths in the module name may fail here because // they the wrong directory separator or are relative. // Fix with the code below: // FullyQualifiedName = FullyQualifiedName.Select(ms => ms.WithNormalizedName(Context, SessionState.Path.CurrentLocation.Path)).ToArray(); 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); } } }
private List <CorrectionExtent> GetCorrectionExtent(string field, IScriptExtent extent, PSModuleInfo psModuleInfo) { Debug.Assert(field != null); Debug.Assert(psModuleInfo != null); Debug.Assert(extent != null); var corrections = new List <CorrectionExtent>(); string correctionText = null; switch (field) { case functionsToExport: correctionText = GetListLiteral(psModuleInfo.ExportedFunctions); break; case cmdletsToExport: correctionText = GetListLiteral(psModuleInfo.ExportedCmdlets); break; case aliasesToExport: correctionText = GetListLiteral(psModuleInfo.ExportedAliases); break; default: throw new NotImplementedException(string.Format("{0} not implemented", field)); } string description = string.Format( Strings.UseToExportFieldsInManifestCorrectionDescription, extent.Text, correctionText); corrections.Add(new CorrectionExtent( extent.StartLineNumber, extent.EndLineNumber, extent.StartColumnNumber, extent.EndColumnNumber, correctionText, extent.File, description)); return(corrections); }
public ModuleInfo(PSModuleInfo info) { Path = info.ModuleBase; Name = info.Name; }
/// <summary> /// Gets a list of matching commands /// </summary> /// <param name="pattern">command pattern</param> /// <param name="commandOrigin"></param> /// <param name="context"></param> /// <param name="rediscoverImportedModules"></param> /// <param name="moduleVersionRequired"></param> /// <returns></returns> internal static IEnumerable<CommandInfo> GetMatchingCommands(string pattern, ExecutionContext context, CommandOrigin commandOrigin, bool rediscoverImportedModules = false, bool moduleVersionRequired = 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(true, false, context)) { // Skip modules that have already been loaded so that we don't expose private commands. string moduleName = Path.GetFileNameWithoutExtension(modulePath); var 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, null, null); tempModuleInfo.SetModuleBase(psModule.ModuleBase); foreach (var entry in psModule.ExportedCommands) { if (commandPattern.IsMatch(entry.Value.Name)) { CommandInfo current = null; switch (entry.Value.CommandType) { case CommandTypes.Alias: current = new AliasInfo(entry.Value.Name, null, context); break; case CommandTypes.Workflow: current = new WorkflowInfo(entry.Value.Name, ScriptBlock.EmptyScriptBlock, 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, null, null, null, context); break; default: Dbg.Assert(false, "cannot be hit"); break; } current.Module = tempModuleInfo; yield return current; } } continue; } } string moduleShortName = System.IO.Path.GetFileNameWithoutExtension(modulePath); var exportedCommands = AnalysisCache.GetExportedCommands(modulePath, false, context); if (exportedCommands == null) { continue; } tempModuleInfo = new PSModuleInfo(moduleShortName, modulePath, null, null); if (InitialSessionState.IsEngineModule(moduleShortName)) { tempModuleInfo.SetModuleBase(Utils.GetApplicationBase(Utils.DefaultPowerShellShellID)); } //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 (var pair in exportedCommands) { var commandName = pair.Key; var commandTypes = pair.Value; if (commandPattern.IsMatch(commandName)) { 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 }; } if ((commandTypes & CommandTypes.Workflow) == CommandTypes.Workflow) { yield return new WorkflowInfo(commandName, ScriptBlock.EmptyScriptBlock, context) { Module = tempModuleInfo }; } } } } } } }
public ModulePageMetadataOutput(PSModuleInfo moduleInfo) { ModuleInfo = moduleInfo; }
internal void AddTypeFromUsingModule(Parser parser, TypeDefinitionAst typeDefinitionAst, PSModuleInfo moduleInfo) { TypeLookupResult result; if (_typeTable.TryGetValue(typeDefinitionAst.Name, out result)) { if (result.ExternalNamespaces != null) { // override external type by the type defined in the current namespace result.ExternalNamespaces.Add(moduleInfo.Name); } } else { var newLookupEntry = new TypeLookupResult(typeDefinitionAst) { ExternalNamespaces = new List<string>() }; newLookupEntry.ExternalNamespaces.Add(moduleInfo.Name); _typeTable.Add(typeDefinitionAst.Name, newLookupEntry); } string fullName = SymbolResolver.GetModuleQualifiedName(moduleInfo.Name, typeDefinitionAst.Name); if (_typeTable.TryGetValue(fullName, out result)) { parser.ReportError(typeDefinitionAst.Extent, () => ParserStrings.MemberAlreadyDefined, fullName); } else { _typeTable.Add(fullName, new TypeLookupResult(typeDefinitionAst)); } }
public static ModulePageMetadataOutput ToModulePageMetadataOutput(this PSModuleInfo moduleInfo) => new ModulePageMetadataOutput(moduleInfo);
/// <summary> /// If we cannot use psget to get swidtag information, we will try to fill in some of the information /// </summary> /// <param name="packageProvider"></param> /// <param name="psModuleInfo"></param> private void ProvideSwidTagInformation(PackageProvider packageProvider, PSModuleInfo psModuleInfo) { if (packageProvider == null || psModuleInfo == null) { return; } packageProvider.VersionScheme = "MultiPartNumeric"; Microsoft.PackageManagement.Internal.Packaging.SoftwareMetadata softwareMetadata = new Microsoft.PackageManagement.Internal.Packaging.SoftwareMetadata(); bool changed = false; var type = psModuleInfo.GetType(); // introduced in ps 2.0 if (!string.IsNullOrWhiteSpace(psModuleInfo.Description)) { softwareMetadata.Description = psModuleInfo.Description; changed = true; } // introduced in ps 3.0 if (!string.IsNullOrWhiteSpace(psModuleInfo.Copyright)) { softwareMetadata.AddAttribute("copyright", psModuleInfo.Copyright); changed = true; } // tags is introduced in ps 5.0 var tagsProperty = type.GetProperty("Tags"); bool isV5 = tagsProperty != null; if (isV5) { // introduced in ps 5.0 var tags = tagsProperty.GetValue(psModuleInfo); // check that we have something in tags if (tags is IEnumerable <string> && (tags as IEnumerable <string>).Any()) { softwareMetadata.AddAttribute("tags", string.Join(" ", (tags as IEnumerable <string>).Distinct())); changed = true; } var releaseNotes = type.GetProperty("ReleaseNotes").GetValue(psModuleInfo); // check that we have something in releasenotes if (releaseNotes is string && !string.IsNullOrWhiteSpace(type.GetProperty("ReleaseNotes").GetValue(psModuleInfo) as string)) { softwareMetadata.AddAttribute("tags", string.Join(" ", (tags as IEnumerable <string>).Distinct())); changed = true; } } if (changed) { packageProvider.AddElement(softwareMetadata); } if (isV5) { var iconUri = type.GetProperty("IconUri").GetValue(psModuleInfo); // introduced in ps 5.0 if (iconUri is Uri) { packageProvider.AddLink(iconUri as Uri, "icon"); } var licenseUri = type.GetProperty("LicenseUri").GetValue(psModuleInfo); // introduced in ps 5.0 if (licenseUri is Uri) { packageProvider.AddLink(licenseUri as Uri, "license"); } var projectUri = type.GetProperty("ProjectUri").GetValue(psModuleInfo); // introduced in ps 5.0 if (projectUri is Uri) { packageProvider.AddLink(projectUri as Uri, "project"); } } // introduced in ps 3.0 if (!string.IsNullOrWhiteSpace(psModuleInfo.Author)) { packageProvider.AddEntity(psModuleInfo.Author, null, "author"); } // introduced in ps 3.0 if (!string.IsNullOrWhiteSpace(psModuleInfo.CompanyName)) { packageProvider.AddEntity(psModuleInfo.CompanyName, null, "owner"); } }
/// <summary> /// Create the new module... /// </summary> protected override void EndProcessing() { // Create a module from a scriptblock... if (_scriptBlock != null) { string gs = System.Guid.NewGuid().ToString(); if (String.IsNullOrEmpty(_name)) { _name = PSModuleInfo.DynamicModulePrefixString + gs; } try { Context.Modules.IncrementModuleNestingDepth(this, _name); List <object> results = null; PSModuleInfo localModule = null; try { // The path for a "dynamic" module will be a GUID so it's unique. localModule = Context.Modules.CreateModule(_name, gs, _scriptBlock, null, out results, _arguments); // Export all functions and variables if no exports were specified... if (!localModule.SessionState.Internal.UseExportList) { List <WildcardPattern> cmdletPatterns = BaseCmdletPatterns ?? MatchAll; List <WildcardPattern> functionPatterns = BaseFunctionPatterns ?? MatchAll; ModuleIntrinsics.ExportModuleMembers(this, localModule.SessionState.Internal, functionPatterns, cmdletPatterns, BaseAliasPatterns, BaseVariablePatterns, null); } } catch (RuntimeException e) { // Preserve the inner module invocation info... e.ErrorRecord.PreserveInvocationInfoOnce = true; WriteError(e.ErrorRecord); } // If the module was created successfully, then process the result... if (localModule != null) { if (_returnResult) { // import the specified members... ImportModuleMembers(localModule, string.Empty /* no -Prefix for New-Module cmdlet */); WriteObject(results, true); } else if (_asCustomObject) { WriteObject(localModule.AsCustomObject()); } else { // import the specified members... ImportModuleMembers(localModule, string.Empty /* no -Prefix for New-Module cmdlet */); WriteObject(localModule); } } } finally { Context.Modules.DecrementModuleNestingCount(); } return; } }
public void OnRemove(PSModuleInfo psModuleInfo) { AppDomain.CurrentDomain.AssemblyResolve -= DependencyResolution.ResolveExtenionAbstraction; }
/// <summary> /// Checks if the module contains HelpInfoUri /// </summary> /// <param name="module"></param> /// <param name="moduleName"></param> /// <returns></returns> private static bool HasHelpInfoUri(PSModuleInfo module, string moduleName) { // The core module is really a SnapIn, so module will be null if (!String.IsNullOrEmpty(moduleName) && moduleName.Equals(InitialSessionState.CoreModule, StringComparison.OrdinalIgnoreCase)) { return true; } if (module == null) { return false; } return !String.IsNullOrEmpty(module.HelpInfoUri); }
/// <inheritdoc/> public void OnRemove(PSModuleInfo psModuleInfo) { SubsystemManager.UnregisterSubsystem <ICommandPredictor>(AzPredictor.Identifier); }
public void OnRemove(PSModuleInfo module) { AppDomain.CurrentDomain.AssemblyResolve -= ResolveAssembly; }
/// <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 is 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 }); } } } } } } }
private PSModuleInfo ConvertCimModuleInfoToPSModuleInfo(RemoteDiscoveryHelper.CimModule cimModule, string computerName) { try { bool containedErrors = false; if (cimModule.MainManifest is null) { return(GetModuleInfoForRemoteModuleWithoutManifest(cimModule)); } string temporaryModuleManifestPath = Path.Combine( RemoteDiscoveryHelper.GetModulePath(cimModule.ModuleName, null, computerName, this.Context.CurrentRunspace), Path.GetFileName(cimModule.ModuleName)); Hashtable mainData = null; if (!containedErrors) { mainData = RemoteDiscoveryHelper.ConvertCimModuleFileToManifestHashtable( cimModule.MainManifest, temporaryModuleManifestPath, this, ref containedErrors); if (mainData is null) { return(GetModuleInfoForRemoteModuleWithoutManifest(cimModule)); } } if (!containedErrors) { mainData = RemoteDiscoveryHelper.RewriteManifest(mainData); } Hashtable localizedData = mainData; // TODO/FIXME - this needs full path support from the provider PSModuleInfo moduleInfo = null; if (!containedErrors) { ImportModuleOptions throwAwayOptions = new ImportModuleOptions(); moduleInfo = LoadModuleManifest( temporaryModuleManifestPath, null, // scriptInfo mainData, localizedData, 0 /* - don't write errors, don't load elements, don't return null on first error */, this.BaseMinimumVersion, this.BaseMaximumVersion, this.BaseRequiredVersion, this.BaseGuid, ref throwAwayOptions, ref containedErrors); } if ((moduleInfo is null) || containedErrors) { moduleInfo = GetModuleInfoForRemoteModuleWithoutManifest(cimModule); } return(moduleInfo); } catch (Exception e) { ErrorRecord errorRecord = RemoteDiscoveryHelper.GetErrorRecordForProcessingOfCimModule(e, cimModule.ModuleName); this.WriteError(errorRecord); return(null); } }
internal void AddTypeFromUsingModule(Parser parser, TypeDefinitionAst typeDefinitionAst, PSModuleInfo moduleInfo) { TypeLookupResult result; if (_typeTable.TryGetValue(typeDefinitionAst.Name, out result)) { if (result.ExternalNamespaces != null) { // override external type by the type defined in the current namespace result.ExternalNamespaces.Add(moduleInfo.Name); } } else { var newLookupEntry = new TypeLookupResult(typeDefinitionAst) { ExternalNamespaces = new List <string>() }; newLookupEntry.ExternalNamespaces.Add(moduleInfo.Name); _typeTable.Add(typeDefinitionAst.Name, newLookupEntry); } string fullName = SymbolResolver.GetModuleQualifiedName(moduleInfo.Name, typeDefinitionAst.Name); if (_typeTable.TryGetValue(fullName, out result)) { parser.ReportError(typeDefinitionAst.Extent, nameof(ParserStrings.MemberAlreadyDefined), ParserStrings.MemberAlreadyDefined, fullName); } else { _typeTable.Add(fullName, new TypeLookupResult(typeDefinitionAst)); } }
/// <summary> /// Create the new module... /// </summary> protected override void EndProcessing() { // Create a module from a scriptblock... if (_scriptBlock != null) { // Check ScriptBlock language mode. If it is different than the context language mode // then throw error since private trusted script functions may be exposed. if (Context.LanguageMode == PSLanguageMode.ConstrainedLanguage && _scriptBlock.LanguageMode == PSLanguageMode.FullLanguage) { this.ThrowTerminatingError( new ErrorRecord( new PSSecurityException(Modules.CannotCreateModuleWithScriptBlock), "Modules_CannotCreateModuleWithFullLanguageScriptBlock", ErrorCategory.SecurityError, null)); } string gs = System.Guid.NewGuid().ToString(); if (string.IsNullOrEmpty(_name)) { _name = PSModuleInfo.DynamicModulePrefixString + gs; } try { Context.Modules.IncrementModuleNestingDepth(this, _name); List <object> results = null; PSModuleInfo localModule = null; try { // The path for a "dynamic" module will be a GUID so it's unique. localModule = Context.Modules.CreateModule(_name, gs, _scriptBlock, null, out results, _arguments); // Export all functions and variables if no exports were specified... if (!localModule.SessionState.Internal.UseExportList) { List <WildcardPattern> cmdletPatterns = BaseCmdletPatterns ?? MatchAll; List <WildcardPattern> functionPatterns = BaseFunctionPatterns ?? MatchAll; ModuleIntrinsics.ExportModuleMembers(this, localModule.SessionState.Internal, functionPatterns, cmdletPatterns, BaseAliasPatterns, BaseVariablePatterns, null); } } catch (RuntimeException e) { // Preserve the inner module invocation info... e.ErrorRecord.PreserveInvocationInfoOnce = true; WriteError(e.ErrorRecord); } // If the module was created successfully, then process the result... if (localModule != null) { if (_returnResult) { // import the specified members... ImportModuleMembers(localModule, string.Empty /* no -Prefix for New-Module cmdlet */); WriteObject(results, true); } else if (_asCustomObject) { WriteObject(localModule.AsCustomObject()); } else { // import the specified members... ImportModuleMembers(localModule, string.Empty /* no -Prefix for New-Module cmdlet */); WriteObject(localModule); } } } finally { Context.Modules.DecrementModuleNestingCount(); } return; } }
public static PsModuleHelpInfo ToModuleInfo(this PSModuleInfo moduleInfo) => new PsModuleHelpInfo(moduleInfo);
private IEnumerable <KeyValuePair <string, PSModuleInfo> > ScanPrivateDataForProviders(PsRequest request, string baseFolder, Hashtable privateData, PSModuleInfo moduleInfo) { var providers = privateData.GetStringCollection("PackageManagementProviders").ReEnumerable(); if (providers.Any()) { // found a module that is advertizing one or more Providers. foreach (var provider in providers) { var fullPath = provider; try { if (!Path.IsPathRooted(provider)) { fullPath = Path.GetFullPath(Path.Combine(baseFolder, provider)); } } catch { // got an error from the path. continue; } if (Directory.Exists(fullPath) || File.Exists(fullPath)) { // looks like we have something that could definitely be a // a module path. var result = new KeyValuePair <string, PSModuleInfo>(fullPath, moduleInfo); AddToPowerShellProviderCacheTable(result); yield return(result); } else { request.Verbose(string.Format(CultureInfo.CurrentCulture, Resources.Messages.FileNotFound, fullPath)); } } } else { request.Debug(string.Format(Resources.Messages.PackageManagementProvidersNotFound, baseFolder)); } }
public PsModuleHelpInfo(PSModuleInfo moduleInfo) : this(moduleInfo?.Name ?? String.Empty, moduleInfo?.Guid ?? Guid.NewGuid(), moduleInfo?.Description ?? String.Empty) { }
private IEnumerable <KeyValuePair <string, PSModuleInfo> > GetPackageManagementModules(PsRequest request, PSModuleInfo module, Version requiredVersion, Version minimumVersion, Version maximumVersion) { // skip modules that we know don't contain any PM modules if (!_exclusionList.Contains(module.Name)) { var privateData = module.PrivateData as Hashtable; if (privateData != null) { if (requiredVersion != null) { if ((FourPartVersion)module.Version == (FourPartVersion)requiredVersion) { return(ScanPrivateDataForProviders(request, Path.GetDirectoryName(module.Path), privateData, module).ToArray()); } else { return(Enumerable.Empty <KeyValuePair <string, PSModuleInfo> >()); } } if ((minimumVersion != null) && ((FourPartVersion)module.Version < (FourPartVersion)minimumVersion)) { return(Enumerable.Empty <KeyValuePair <string, PSModuleInfo> >()); } if ((maximumVersion != null) && ((FourPartVersion)module.Version > (FourPartVersion)maximumVersion)) { return(Enumerable.Empty <KeyValuePair <string, PSModuleInfo> >()); } return(ScanPrivateDataForProviders(request, Path.GetDirectoryName(module.Path), privateData, module).ToArray()); } } return(Enumerable.Empty <KeyValuePair <string, PSModuleInfo> >()); }
protected InitialSessionStateEntry(string name) { this.name = name; this.psSnapIn = null; this.module = null; }
private PackageProvider AnalyzeModule(PsRequest request, string modulePath, Version requiredVersion, bool force, bool logWarning = true, PSModuleInfo psModuleInfo = null) { if (string.IsNullOrWhiteSpace(modulePath)) { return(null); } request.Debug("Attempting to load PowerShell Provider Module [{0}]", modulePath); if (string.Equals(Path.GetExtension(modulePath), ".dll", StringComparison.OrdinalIgnoreCase)) { if (psModuleInfo != null) { // fake provider and returns it var result = new PackageProvider(new DefaultPackageProvider(psModuleInfo.Name, psModuleInfo.Version.ToString())) { ProviderPath = modulePath, Version = psModuleInfo.Version, IsLoaded = false }; AddToPackageProviderCacheTable(result); return(result); } else { // psmoduleinfo is only null when this function is called in loadavailableprovider // but in that case we want to load the provider directly anyway so we can do this // if the path is a .dll then we ask packagemanagement to load it for us // it will also register the dll PackageManagementService.LoadProviderAssembly(request, modulePath, true); // now let's checked whether we can find it in the list of loaded providers foreach (var loadedProvider in PackageManagementService.PackageProviders) { // the one loaded should have the same path if (string.Equals(loadedProvider.ProviderPath, modulePath, StringComparison.OrdinalIgnoreCase)) { return(loadedProvider); } } // if we reached here then we have failed to load the provider :( return(null); } } string requiredVersionString = requiredVersion.ToString(); var provider = Create(request, modulePath, requiredVersionString, force, logWarning); if (provider != null) { var providerName = provider.GetPackageProviderName(); if (!string.IsNullOrWhiteSpace(providerName)) { request.Debug(string.Format(CultureInfo.CurrentCulture, Resources.Messages.SuccessfullyLoadedModule, modulePath)); // looks good to me, let's add this to the list of moduels this meta provider can create. var packageProvider = new PackageProvider(provider.As <IPackageProvider>()) { IsLoaded = true, Version = provider.GetProviderVersion(), ProviderPath = modulePath }; // take out powershell get var psgetprovider = PackageManagementService.PackageProviders.FirstOrDefault(pv => string.Equals(pv.ProviderName, PowerShellGet, StringComparison.OrdinalIgnoreCase)); if (psModuleInfo != null) { // add swidtag information using moduleinfo // however, this won't give us as much information yet // we may have to fill this up later ProvideSwidTagInformation(packageProvider, psModuleInfo); } AddToPackageProviderCacheTable(packageProvider); _availableProviders.AddOrSet(providerName, provider); return(packageProvider); } else { provider.Dispose(); provider = null; request.Debug(string.Format(CultureInfo.CurrentCulture, Resources.Messages.ProviderNameIsNullOrEmpty, modulePath)); } } return(null); }
public RequiredModuleSpecs(PSModuleInfo moduleInfo) { Name = moduleInfo.Name; Version = moduleInfo.Version; Guid = moduleInfo.Guid; }