internal Collection<ProviderInfo> Get(PSModuleInfo moduleInfo)
{
var providers = from p in GetAll()
where p.Module != null && p.Module.Equals(moduleInfo)
select p;
return new Collection<ProviderInfo>(providers.ToList());
}
/// <summary>
/// Creates an instance of the ShowCommandModuleInfo class based on a CommandInfo object
/// </summary>
///
/// <param name="other">
/// The object to wrap.
/// </param>
public ShowCommandModuleInfo(PSModuleInfo other)
{
if (null == other)
{
throw new ArgumentNullException("other");
}
this.Name = other.Name;
}
public WorkflowInfo(
string name,
string definition,
ScriptBlock workflow,
string xamlDefinition,
WorkflowInfo[] workflowsCalled,
PSModuleInfo module)
: base (name, workflow, null)
{
}
internal ModuleSpecification(PSModuleInfo moduleInfo)
{
if (moduleInfo == null)
{
throw new ArgumentNullException("moduleInfo");
}
this.Name = moduleInfo.Name;
this.Version = moduleInfo.Version;
this.Guid = new System.Guid?(moduleInfo.Guid);
}
protected override void BeginProcessing()
{
_affectedModule = ExecutionContext.SessionState.Module;
if (_affectedModule == null)
{
throw new PSInvalidOperationException("You can execute Export-ModuleMember only inside a module",
"Modules_CanOnlyExecuteExportModuleMemberInsideAModule",
ErrorCategory.PermissionDenied);
}
}
private PSModuleInfo LoadModuleByPath(Path path)
{
// ALWAYS derive from global scope: the Scope parameter only defines where stuff is imported to
var sessionState = new SessionState(_executionContext.SessionStateGlobal.RootSessionState);
sessionState.IsScriptScope = true;
sessionState.PSVariable.Set("PSScriptRoot", path.GetDirectory());
var moduleInfo = new PSModuleInfo(path, path.GetFileNameWithoutExtension(), sessionState);
sessionState.SetModule(moduleInfo);
LoadFileIntoModule(moduleInfo, path);
return moduleInfo;
}
private void RegisterModuleCleanUp(PSModuleInfo moduleInfo)
{
if (moduleInfo == null)
{
throw PSTraceSource.NewArgumentNullException("moduleInfo");
}
string sourceIdentifier = StringUtil.Format(ImplicitRemotingStrings.EventSourceIdentifier, base.Session.InstanceId, base.ModuleGuid);
PSEventSubscriber subscriber = base.Context.Events.SubscribeEvent(base.Session.Runspace, "StateChanged", sourceIdentifier, PSObject.AsPSObject(moduleInfo), base.Context.Engine.ParseScriptBlock("& {\r\n if ('Closed' -eq $eventArgs.RunspaceStateInfo.State)\r\n {\r\n $sourceIdentifier = [system.management.automation.wildcardpattern]::Escape($eventSubscriber.SourceIdentifier)\r\n Unregister-Event -SourceIdentifier $sourceIdentifier -Force -ErrorAction SilentlyContinue\r\n\r\n $moduleInfo = $event.MessageData\r\n Remove-Module -ModuleInfo $moduleInfo -Force -ErrorAction SilentlyContinue\r\n\r\n Remove-Item -LiteralPath $moduleInfo.ModuleBase -Recurse -Force -ErrorAction SilentlyContinue\r\n $moduleInfo = $null\r\n }\r\n}\r\n ", false), true, false);
ScriptBlock newClosure = base.Context.Engine.ParseScriptBlock("\r\n $sourceIdentifier = [system.management.automation.wildcardpattern]::Escape($eventSubscriber.SourceIdentifier)\r\n Unregister-Event -SourceIdentifier $sourceIdentifier -Force -ErrorAction SilentlyContinue\r\n\r\n if ($previousScript -ne $null)\r\n {\r\n & $previousScript $args\r\n }\r\n ", false).GetNewClosure();
newClosure.Module.SessionState.PSVariable.Set("eventSubscriber", subscriber);
newClosure.Module.SessionState.PSVariable.Set("previousScript", moduleInfo.OnRemove);
moduleInfo.OnRemove = newClosure;
}
// for all fields
internal ProviderInfo(SessionState sessionState, Type implementingType, string name, string description, string home,
string helpFile, PSSnapInInfo psSnapIn, PSModuleInfo module)
{
_sessionState = sessionState;
Module = module;
PSSnapIn = psSnapIn;
Name = name;
Description = description;
Home = home;
ImplementingType = implementingType;
Capabilities = GetCapabilities(implementingType);
HelpFile = helpFile;
}
internal CommandInfo(CommandInfo other)
{
this._name = string.Empty;
this._type = CommandTypes.Application;
this._prefix = "";
this._module = other._module;
this._visibility = other._visibility;
this._arguments = other._arguments;
this.Context = other.Context;
this._name = other._name;
this._type = other._type;
this._copiedCommand = other;
this.DefiningLanguageMode = other.DefiningLanguageMode;
}
protected virtual void Dispose(bool disposing) {
if (disposing) {
if (_powershell != null) {
_powershell.Dispose();
_powershell = null;
}
if (_reentrancyLock != null) {
_reentrancyLock.Dispose();
_reentrancyLock = null;
}
_module = null;
}
}
internal CmdletInfo(string name, Type implementingType, string helpFile, PSSnapInInfo snapin, PSModuleInfo module)
: base(name, CommandTypes.Cmdlet)
{
int i = name.IndexOf('-');
if (i == -1)
{
throw new Exception("InvalidCmdletNameFormat " + name);
}
ParameterInfoLookupTable = new Dictionary<string, CommandParameterInfo>(StringComparer.CurrentCultureIgnoreCase);
Verb = name.Substring(0, i);
Noun = name.Substring(i + 1);
ImplementingType = implementingType;
HelpFile = helpFile;
_validationException = null;
PSSnapIn = snapin;
Module = module;
GetParameterSetInfo(implementingType);
GetOutputTypes(implementingType);
}
private void GetAllNestedModules(PSModuleInfo module, ref List<PSModuleInfo> nestedModulesWithNoCircularReference)
{
List<PSModuleInfo> list = new List<PSModuleInfo>();
if ((module.NestedModules != null) && (module.NestedModules.Count > 0))
{
foreach (PSModuleInfo info in module.NestedModules)
{
if (!nestedModulesWithNoCircularReference.Contains(info))
{
nestedModulesWithNoCircularReference.Add(info);
list.Add(info);
}
}
foreach (PSModuleInfo info2 in list)
{
this.GetAllNestedModules(info2, ref nestedModulesWithNoCircularReference);
}
}
}
public PowerShellProviderBase(PowerShell ps, PSModuleInfo module) {
if (module == null) {
throw new ArgumentNullException("module");
}
_powershell = ps;
_module = module;
// combine all the cmdinfos we care about
// but normalize the keys as we go (remove any '-' '_' chars)
foreach (var k in _module.ExportedAliases.Keys) {
_allCommands.AddOrSet(k.Replace("-", "").Replace("_", ""), _module.ExportedAliases[k]);
}
foreach (var k in _module.ExportedCmdlets.Keys) {
_allCommands.AddOrSet(k.Replace("-", "").Replace("_", ""), _module.ExportedCmdlets[k]);
}
foreach (var k in _module.ExportedFunctions.Keys) {
_allCommands.AddOrSet(k.Replace("-", "").Replace("_", ""), _module.ExportedFunctions[k]);
}
}
private void LoadFileIntoModule(PSModuleInfo moduleInfo, Path path)
{
// prevents accidental loops while loading a module
moduleInfo.NestingDepth++;
if (moduleInfo.NestingDepth > 10)
{
var msg = "The module is too deeply nested. A module can be only nested 10 times. Make sure to check" +
" the loading order of your module";
throw new PSInvalidOperationException(msg, "Modules_ModuleTooDeeplyNested",
ErrorCategory.InvalidOperation);
}
moduleInfo.Path = path; // update path for nested modules
var stringComparer = StringComparer.InvariantCultureIgnoreCase;
var ext = path.GetExtension();
if (_scriptExtensions.Contains(ext, stringComparer))
{
moduleInfo.ModuleType = ModuleType.Script;
LoadScriptModule(moduleInfo, path); // actually load the script
}
else if (_binaryExtensions.Contains(ext, stringComparer))
{
moduleInfo.ModuleType = ModuleType.Binary;
LoadBinaryModule(moduleInfo, path);
}
else if (_manifestExtensions.Contains(ext, stringComparer))
{
moduleInfo.ModuleType = ModuleType.Manifest;
LoadManifestModule(moduleInfo, path);
}
else
{
var msg = "The extension '" + ext + "' is currently not supported";
throw new PSInvalidOperationException(msg, "Modules_InvalidFileExtension",
ErrorCategory.InvalidOperation, null, false);
}
moduleInfo.ValidateExportedMembers();
}
private bool ModuleProvidesCurrentSessionDrive(PSModuleInfo module)
{
if (module.ModuleType == ModuleType.Binary)
{
foreach (KeyValuePair<string, List<ProviderInfo>> pair in base.Context.TopLevelSessionState.Providers)
{
foreach (ProviderInfo info in pair.Value)
{
if (info.ImplementingType.Assembly.Location.Equals(module.Path, StringComparison.OrdinalIgnoreCase))
{
foreach (PSDriveInfo info2 in base.Context.TopLevelSessionState.GetDrivesForProvider(info.FullName))
{
if (info2 == base.SessionState.Drive.Current)
{
return true;
}
}
}
}
}
}
return false;
}
internal void SetModule(PSModuleInfo module)
{
Module = module;
}
internal void AddRequiredModule(PSModuleInfo requiredModule)
{
AddModuleToList(requiredModule, this._requiredModules);
}
private static void AddModuleToList(PSModuleInfo module, List<PSModuleInfo> moduleList)
{
foreach (PSModuleInfo info in moduleList)
{
if (info.Path.Equals(module.Path, StringComparison.OrdinalIgnoreCase))
{
return;
}
}
moduleList.Add(module);
}
private void GetAllNestedModules(PSModuleInfo module, ref List<PSModuleInfo> nestedModulesWithNoCircularReference)
{
List<PSModuleInfo> nestedModules = new List<PSModuleInfo>();
if (module.NestedModules != null && module.NestedModules.Count > 0)
{
foreach (var nestedModule in module.NestedModules)
{
if (!nestedModulesWithNoCircularReference.Contains(nestedModule))
{
nestedModulesWithNoCircularReference.Add(nestedModule);
nestedModules.Add(nestedModule);
}
}
foreach (PSModuleInfo child in nestedModules)
{
GetAllNestedModules(child, ref nestedModulesWithNoCircularReference);
}
}
}
public WorkflowInfo(string name, string definition, ScriptBlock workflow, string xamlDefinition, WorkflowInfo[] workflowsCalled, PSModuleInfo module) : this(name, definition, workflow, xamlDefinition, workflowsCalled)
{
base.SetModule(module);
}
internal CmdletInfo(string name, Type implementingType, string helpFile, PSModuleInfo module)
: this(name, implementingType, helpFile, null, module)
{
}
/// <summary>
/// Creates an instance of the workflowInfo class with the specified name and ScriptBlock
/// </summary>
/// <param name="name">
/// The name of the workflow.
/// </param>
/// <param name="definition">
/// The script body defining the workflow.
/// </param>
/// <param name="workflow">
/// The ScriptBlock for the workflow
/// </param>
/// <param name="xamlDefinition">
/// The XAML used to define the workflow
/// </param>
/// <param name="workflowsCalled">
/// The workflows referenced within <paramref name="xamlDefinition"/>.
/// </param>
/// <param name="module">module.</param>
/// <exception cref="ArgumentNullException">
/// If <paramref name="workflow"/> is null.
/// </exception>
internal WorkflowInfo(string name, string definition, ScriptBlock workflow, string xamlDefinition, WorkflowInfo[] workflowsCalled, PSModuleInfo module)
: this(name, definition, workflow, xamlDefinition, workflowsCalled)
{
this.Module = module;
}
internal static void CacheModuleExports(PSModuleInfo module, ExecutionContext context)
{
ModuleIntrinsics.Tracer.WriteLine("Requested caching for {0}", module.Name);
// Don't cache incompatible modules on the system32 module path even if loaded with
// -SkipEditionCheck, since it will break subsequent sessions.
if (!module.IsConsideredEditionCompatible)
{
ModuleIntrinsics.Tracer.WriteLine($"Module '{module.Name}' not edition compatible and not cached.");
return;
}
DateTime lastWriteTime;
ModuleCacheEntry moduleCacheEntry;
GetModuleEntryFromCache(module.Path, out lastWriteTime, out moduleCacheEntry);
var realExportedCommands = module.ExportedCommands;
var realExportedClasses = module.GetExportedTypeDefinitions();
ConcurrentDictionary <string, CommandTypes> exportedCommands;
ConcurrentDictionary <string, TypeAttributes> exportedClasses;
// First see if the existing module info is sufficient. GetModuleEntryFromCache does LastWriteTime
// verification, so this will also return nothing if the cache is out of date or corrupt.
if (moduleCacheEntry != null)
{
bool needToUpdate = false;
// We need to iterate and check as exportedCommands will have more item as it can have aliases as well.
exportedCommands = moduleCacheEntry.Commands;
foreach (var pair in realExportedCommands)
{
var commandName = pair.Key;
var realCommandType = pair.Value.CommandType;
CommandTypes commandType;
if (!exportedCommands.TryGetValue(commandName, out commandType) || commandType != realCommandType)
{
needToUpdate = true;
break;
}
}
exportedClasses = moduleCacheEntry.Types;
foreach (var pair in realExportedClasses)
{
var className = pair.Key;
var realTypeAttributes = pair.Value.TypeAttributes;
TypeAttributes typeAttributes;
if (!exportedClasses.TryGetValue(className, out typeAttributes) ||
typeAttributes != realTypeAttributes)
{
needToUpdate = true;
break;
}
}
// Update or not, we've analyzed commands and types now.
moduleCacheEntry.TypesAnalyzed = true;
if (!needToUpdate)
{
ModuleIntrinsics.Tracer.WriteLine("Existing cached info up-to-date. Skipping.");
return;
}
exportedCommands.Clear();
exportedClasses.Clear();
}
else
{
exportedCommands = new ConcurrentDictionary <string, CommandTypes>(3, realExportedCommands.Count, StringComparer.OrdinalIgnoreCase);
exportedClasses = new ConcurrentDictionary <string, TypeAttributes>(1, realExportedClasses.Count, StringComparer.OrdinalIgnoreCase);
moduleCacheEntry = new ModuleCacheEntry
{
ModulePath = module.Path,
LastWriteTime = lastWriteTime,
Commands = exportedCommands,
TypesAnalyzed = true,
Types = exportedClasses
};
moduleCacheEntry = s_cacheData.Entries.GetOrAdd(module.Path, moduleCacheEntry);
}
// We need to update the cache
foreach (var exportedCommand in realExportedCommands.Values)
{
ModuleIntrinsics.Tracer.WriteLine("Caching command: {0}", exportedCommand.Name);
exportedCommands.GetOrAdd(exportedCommand.Name, exportedCommand.CommandType);
}
foreach (var pair in realExportedClasses)
{
var className = pair.Key;
ModuleIntrinsics.Tracer.WriteLine("Caching command: {0}", className);
moduleCacheEntry.Types.AddOrUpdate(className, pair.Value.TypeAttributes, (k, t) => t);
}
s_cacheData.QueueSerialization();
}
/// <summary>
/// Get suggestion text from suggestion scriptblock with arguments.
/// </summary>
private static string GetSuggestionText(object suggestion, object[] suggestionArgs, PSModuleInfo invocationModule)
{
if (suggestion is ScriptBlock)
{
ScriptBlock suggestionScript = (ScriptBlock)suggestion;
object result = null;
try
{
result = invocationModule.Invoke(suggestionScript, suggestionArgs);
}
catch (Exception)
{
// Catch-all OK. This is a third-party call-out.
return(string.Empty);
}
return((string)LanguagePrimitives.ConvertTo(result, typeof(string), CultureInfo.CurrentCulture));
}
else
{
return((string)LanguagePrimitives.ConvertTo(suggestion, typeof(string), CultureInfo.CurrentCulture));
}
}
private static string GetSuggestionText(object suggestion, PSModuleInfo invocationModule)
{
return(GetSuggestionText(suggestion, null, invocationModule));
}
internal static List <string> GetSuggestion(HistoryInfo lastHistory, object lastError, ArrayList errorList)
{
var returnSuggestions = new List <string>();
PSModuleInfo invocationModule = new PSModuleInfo(true);
invocationModule.SessionState.PSVariable.Set("lastHistory", lastHistory);
invocationModule.SessionState.PSVariable.Set("lastError", lastError);
int initialErrorCount = 0;
// Go through all of the suggestions
foreach (Hashtable suggestion in s_suggestions)
{
initialErrorCount = errorList.Count;
// Make sure the rule is enabled
if (!LanguagePrimitives.IsTrue(suggestion["Enabled"]))
{
continue;
}
SuggestionMatchType matchType = (SuggestionMatchType)LanguagePrimitives.ConvertTo(
suggestion["MatchType"],
typeof(SuggestionMatchType),
CultureInfo.InvariantCulture);
// If this is a dynamic match, evaluate the ScriptBlock
if (matchType == SuggestionMatchType.Dynamic)
{
object result = null;
ScriptBlock evaluator = suggestion["Rule"] as ScriptBlock;
if (evaluator == null)
{
suggestion["Enabled"] = false;
throw new ArgumentException(
SuggestionStrings.RuleMustBeScriptBlock, "Rule");
}
try
{
result = invocationModule.Invoke(evaluator, null);
}
catch (Exception)
{
// Catch-all OK. This is a third-party call-out.
suggestion["Enabled"] = false;
continue;
}
// If it returned results, evaluate its suggestion
if (LanguagePrimitives.IsTrue(result))
{
string suggestionText = GetSuggestionText(suggestion["Suggestion"], (object[])suggestion["SuggestionArgs"], invocationModule);
if (!string.IsNullOrEmpty(suggestionText))
{
string returnString = string.Format(
CultureInfo.CurrentCulture,
"Suggestion [{0},{1}]: {2}",
(int)suggestion["Id"],
(string)suggestion["Category"],
suggestionText);
returnSuggestions.Add(returnString);
}
}
}
else
{
string matchText = string.Empty;
// Otherwise, this is a Regex match against the
// command or error
if (matchType == SuggestionMatchType.Command)
{
matchText = lastHistory.CommandLine;
}
else if (matchType == SuggestionMatchType.Error)
{
if (lastError != null)
{
Exception lastException = lastError as Exception;
if (lastException != null)
{
matchText = lastException.Message;
}
else
{
matchText = lastError.ToString();
}
}
}
else if (matchType == SuggestionMatchType.ErrorId)
{
if (lastError != null && lastError is ErrorRecord errorRecord)
{
matchText = errorRecord.FullyQualifiedErrorId;
}
}
else
{
suggestion["Enabled"] = false;
throw new ArgumentException(
SuggestionStrings.InvalidMatchType,
"MatchType");
}
// If the text matches, evaluate the suggestion
if (Regex.IsMatch(matchText, (string)suggestion["Rule"], RegexOptions.IgnoreCase))
{
string suggestionText = GetSuggestionText(suggestion["Suggestion"], (object[])suggestion["SuggestionArgs"], invocationModule);
if (!string.IsNullOrEmpty(suggestionText))
{
string returnString = string.Format(
CultureInfo.CurrentCulture,
"Suggestion [{0},{1}]: {2}",
(int)suggestion["Id"],
(string)suggestion["Category"],
suggestionText);
returnSuggestions.Add(returnString);
}
}
}
// If the rule generated an error, disable it
if (errorList.Count != initialErrorCount)
{
suggestion["Enabled"] = false;
}
}
return(returnSuggestions);
}
internal void SetModule(PSModuleInfo module)
{
Module = module;
}
private PSModuleInfo CreateModuleImplementation(
string name,
string path,
object moduleCode,
Token callerToken,
SessionState ss,
out ArrayList result,
params object[] arguments)
{
if (ss == null)
{
ss = new SessionState(this._context.EngineSessionState, true, true);
}
SessionStateInternal engineSessionState = this._context.EngineSessionState;
PSModuleInfo psModuleInfo = new PSModuleInfo(name, path, this._context, ss);
ss.Internal.Module = psModuleInfo;
bool flag = false;
int num = 0;
try
{
ArrayList resultList = (ArrayList)null;
this._context.EngineSessionState = ss.Internal;
this._context.EngineSessionState.SetVariableValue("PSScriptRoot", (object)Path.GetDirectoryName(path), CommandOrigin.Internal);
switch (moduleCode)
{
case ExternalScriptInfo externalScriptInfo:
this._context.EngineSessionState.SetVariableValue("MyInvocation", (object)new InvocationInfo((CommandInfo)externalScriptInfo, callerToken), CommandOrigin.Internal);
scriptBlock = externalScriptInfo.ScriptBlock;
break;
case ScriptBlock scriptBlock:
scriptBlock = scriptBlock.Clone(true);
scriptBlock.SessionState = ss;
break;
case string _:
scriptBlock = ScriptBlock.Create(this._context, (string)moduleCode);
break;
}
if (scriptBlock == null)
{
throw ModuleIntrinsics.tracer.NewInvalidOperationException();
}
scriptBlock.SessionStateInternal = ss.Internal;
try
{
if (arguments == null)
{
scriptBlock.InvokeWithPipe(false, true, (object)AutomationNull.Value, (object)AutomationNull.Value, (object)AutomationNull.Value, (Pipe)null, ref resultList);
}
else
{
scriptBlock.InvokeWithPipe(false, true, (object)AutomationNull.Value, (object)AutomationNull.Value, (object)AutomationNull.Value, (Pipe)null, ref resultList, arguments);
}
}
catch (ExitException ex)
{
num = (int)ex.Argument;
flag = true;
}
result = resultList;
}
finally
{
this._context.EngineSessionState = engineSessionState;
}
if (flag)
{
this._context.SetVariable("global:LASTEXITCODE", (object)num);
}
return(psModuleInfo);
}
/// <summary>
/// Check if the given path is valid.
/// </summary>
/// <param name="path"></param>
/// <param name="module"></param>
/// <param name="verifyPathScope"></param>
/// <returns></returns>
private bool IsValidFilePath(string path, PSModuleInfo module, bool verifyPathScope)
{
try
{
if (!System.IO.Path.IsPathRooted(path))
{
// we assume the relative path is under module scope, otherwise we will throw error anyway.
path = System.IO.Path.GetFullPath(module.ModuleBase + "\\" + path);
}
// First, we validate if the path does exist.
if (!File.Exists(path) && !Directory.Exists(path))
{
return false;
}
//Then, we validate if the path is under module scope
if (verifyPathScope && !System.IO.Path.GetFullPath(path).StartsWith(System.IO.Path.GetFullPath(module.ModuleBase), StringComparison.OrdinalIgnoreCase))
{
return false;
}
}
catch (Exception exception)
{
if (exception is ArgumentException || exception is ArgumentNullException || exception is NotSupportedException || exception is PathTooLongException)
{
return false;
}
}
return true;
}
internal void ReportExportedCommands(PSModuleInfo moduleInfo)
{
if (moduleInfo.ExportedCommands.Count == 0)
{
moduleInfo.DeclaredAliasExports = new Collection<string>();
moduleInfo.DeclaredFunctionExports = new Collection<string>();
IEnumerable<CommonCmdletMetadata> collection = Enumerable.Empty<CommonCmdletMetadata>();
if (this.cmdletizationMetadata.Class.InstanceCmdlets != null)
{
collection = collection.Append<CommonCmdletMetadata>(this.GetGetCmdletMetadata());
if (this.cmdletizationMetadata.Class.InstanceCmdlets.Cmdlet != null)
{
collection = collection.Concat<CommonCmdletMetadata>(from c in this.cmdletizationMetadata.Class.InstanceCmdlets.Cmdlet select c.CmdletMetadata);
}
}
if (this.cmdletizationMetadata.Class.StaticCmdlets != null)
{
collection = collection.Concat<CommonCmdletMetadata>((IEnumerable<CommonCmdletMetadata>) (from c in this.cmdletizationMetadata.Class.StaticCmdlets select c.CmdletMetadata));
}
foreach (CommonCmdletMetadata metadata in collection)
{
if (metadata.Aliases != null)
{
foreach (string str in metadata.Aliases)
{
moduleInfo.DeclaredAliasExports.Add(str);
}
}
CommandMetadata commandMetadata = this.GetCommandMetadata(metadata);
moduleInfo.DeclaredFunctionExports.Add(commandMetadata.Name);
}
}
}
internal static void AssociatePSModuleInfoWithSession(PSModuleInfo moduleInfo, CimSession cimSession, Uri resourceUri, string cimNamespace)
{
AssociatePSModuleInfoWithSession(moduleInfo, (object)new Tuple <CimSession, Uri, string>(cimSession, resourceUri, cimNamespace));
}
/// <summary>
/// Determine whether a module info matches a given module specification table and specified PSEdition value.
/// </summary>
/// <param name="moduleInfo"></param>
/// <param name="moduleSpecTable"></param>
/// <param name="edition"></param>
/// <returns></returns>
private static bool ModuleMatch(PSModuleInfo moduleInfo, IDictionary<string, ModuleSpecification> moduleSpecTable, string edition)
{
ModuleSpecification moduleSpecification;
return (String.IsNullOrEmpty(edition) || moduleInfo.CompatiblePSEditions.Contains(edition, StringComparer.OrdinalIgnoreCase)) &&
(!moduleSpecTable.TryGetValue(moduleInfo.Name, out moduleSpecification) || ModuleIntrinsics.IsModuleMatchingModuleSpec(moduleInfo, moduleSpecification));
}
internal static void AssociatePSModuleInfoWithSession(PSModuleInfo moduleInfo, PSSession psSession)
{
AssociatePSModuleInfoWithSession(moduleInfo, (object)psSession);
}
private bool ModuleProvidesCurrentSessionDrive(PSModuleInfo module)
{
if (module.ModuleType == ModuleType.Binary)
{
Dictionary<string, List<ProviderInfo>> providers = Context.TopLevelSessionState.Providers;
foreach (KeyValuePair<string, List<ProviderInfo>> pList in providers)
{
Dbg.Assert(pList.Value != null, "There should never be a null list of entries in the provider table");
foreach (ProviderInfo pInfo in pList.Value)
{
string implTypeAssemblyLocation = pInfo.ImplementingType.GetTypeInfo().Assembly.Location;
if (implTypeAssemblyLocation.Equals(module.Path, StringComparison.OrdinalIgnoreCase))
{
foreach (PSDriveInfo dInfo in Context.TopLevelSessionState.GetDrivesForProvider(pInfo.FullName))
{
if (dInfo == SessionState.Drive.Current)
{
return true;
}
}
}
}
}
}
return false;
}
internal void SetModule(PSModuleInfo module) => this._module = module;
private void ImportModule_ViaLocalModuleInfo(ImportModuleOptions importModuleOptions, PSModuleInfo module)
{
try
{
PSModuleInfo alreadyLoadedModule = null;
Context.Modules.ModuleTable.TryGetValue(module.Path, out alreadyLoadedModule);
if (!BaseForce && IsModuleAlreadyLoaded(alreadyLoadedModule))
{
AddModuleToModuleTables(this.Context, this.TargetSessionState.Internal, alreadyLoadedModule);
// Even if the module has been loaded, import the specified members...
ImportModuleMembers(alreadyLoadedModule, this.BasePrefix, importModuleOptions);
if (BaseAsCustomObject)
{
if (alreadyLoadedModule.ModuleType != ModuleType.Script)
{
string message = StringUtil.Format(Modules.CantUseAsCustomObjectWithBinaryModule, alreadyLoadedModule.Path);
InvalidOperationException invalidOp = new InvalidOperationException(message);
ErrorRecord er = new ErrorRecord(invalidOp, "Modules_CantUseAsCustomObjectWithBinaryModule",
ErrorCategory.PermissionDenied, null);
WriteError(er);
}
else
{
WriteObject(alreadyLoadedModule.AsCustomObject());
}
}
else if (BasePassThru)
{
WriteObject(alreadyLoadedModule);
}
}
else
{
PSModuleInfo moduleToRemove;
if (Context.Modules.ModuleTable.TryGetValue(module.Path, out moduleToRemove))
{
Dbg.Assert(BaseForce, "We should only remove and reload if -Force was specified");
RemoveModule(moduleToRemove);
}
PSModuleInfo moduleToProcess = module;
try
{
// If we're passing in a dynamic module, then the session state will not be
// null and we want to just add the module to the module table. Otherwise, it's
// a module info from Get-Module -list so we need to read the actual module file.
if (module.SessionState == null)
{
if (File.Exists(module.Path))
{
bool found;
moduleToProcess = LoadModule(module.Path, null, this.BasePrefix, /*SessionState*/ null,
ref importModuleOptions,
ManifestProcessingFlags.LoadElements | ManifestProcessingFlags.WriteErrors | ManifestProcessingFlags.NullOnFirstError,
out found);
Dbg.Assert(found, "Module should be found when referenced by its absolute path");
}
}
else if (!string.IsNullOrEmpty(module.Name))
{
// It has a session state and a name but it's not in the module
// table so it's ok to add it
// Add it to the all module tables
AddModuleToModuleTables(this.Context, this.TargetSessionState.Internal, moduleToProcess);
if (moduleToProcess.SessionState != null)
{
ImportModuleMembers(moduleToProcess, this.BasePrefix, importModuleOptions);
}
if (BaseAsCustomObject && moduleToProcess.SessionState != null)
{
WriteObject(module.AsCustomObject());
}
else if (BasePassThru)
{
WriteObject(moduleToProcess);
}
}
}
catch (IOException)
{
;
}
}
}
catch (PSInvalidOperationException e)
{
ErrorRecord er = new ErrorRecord(e.ErrorRecord, e);
WriteError(er);
}
}
internal ScriptBlock CreateBoundScriptBlock(ExecutionContext context, ScriptBlock sb, bool linkToGlobal)
{
PSModuleInfo info = new PSModuleInfo(context, linkToGlobal);
return(info.NewBoundScriptBlock(sb, context));
}
internal void AddNestedModule(PSModuleInfo nestedModule)
{
AddModuleToList(nestedModule, this._nestedModules);
}
internal void SetModule(PSModuleInfo module)
{
Module = module;
_fullName = null;
}
internal static void SetDefaultDynamicNameAndPath(PSModuleInfo module)
{
string str = System.Guid.NewGuid().ToString();
module._path = str;
module._name = "__DynamicModule_" + str;
}
/// <summary>
/// Invoke command Get-DscResource with resource name to find the resource.
/// When found add them to the enumerator. If we have already got it, return the next resource.
/// </summary>
/// <returns>Next DscResource Info object or null if none are found.</returns>
private DscResourceInfo GetNextDscResource()
{
var ps = PowerShell.Create(RunspaceMode.CurrentRunspace).AddCommand("Get-DscResource");
WildcardPattern resourceMatcher = WildcardPattern.Get(_resourceName, WildcardOptions.IgnoreCase);
if (_matchingResourceList == null)
{
Collection <PSObject> psObjs = ps.Invoke();
_matchingResourceList = new Collection <DscResourceInfo>();
bool matchFound = false;
foreach (dynamic resource in psObjs)
{
if (resource.Name != null)
{
string resourceName = resource.Name;
if (resourceMatcher.IsMatch(resourceName))
{
DscResourceInfo resourceInfo = new DscResourceInfo(resourceName,
resource.ResourceType,
resource.Path,
resource.ParentPath,
_context
);
resourceInfo.FriendlyName = resource.FriendlyName;
resourceInfo.CompanyName = resource.CompanyName;
PSModuleInfo psMod = resource.Module as PSModuleInfo;
if (psMod != null)
{
resourceInfo.Module = psMod;
}
if (resource.ImplementedAs != null)
{
ImplementedAsType impType;
if (Enum.TryParse <ImplementedAsType>(resource.ImplementedAs.ToString(), out impType))
{
resourceInfo.ImplementedAs = impType;
}
}
var properties = resource.Properties as IList;
if (properties != null)
{
List <DscResourcePropertyInfo> propertyList = new List <DscResourcePropertyInfo>();
foreach (dynamic prop in properties)
{
DscResourcePropertyInfo propInfo = new DscResourcePropertyInfo();
propInfo.Name = prop.Name;
propInfo.PropertyType = prop.PropertyType;
propInfo.UpdateValues(prop.Values);
propertyList.Add(propInfo);
}
resourceInfo.UpdateProperties(propertyList);
}
_matchingResourceList.Add(resourceInfo);
matchFound = true;
} //if
} //if
} // foreach
if (matchFound)
{
_matchingResource = _matchingResourceList.GetEnumerator();
}
else
{
return(null);
}
}//if
if (!_matchingResource.MoveNext())
{
_matchingResource = null;
}
else
{
return(_matchingResource.Current);
}
return(null);
}
private PSModuleInfo CreateModuleImplementation(string name, string path, object moduleCode, IScriptExtent scriptPosition, SessionState ss, object privateData, out ArrayList result, params object[] arguments)
{
if (ss == null)
{
ss = new SessionState(this._context, true, true);
}
SessionStateInternal engineSessionState = this._context.EngineSessionState;
PSModuleInfo info = new PSModuleInfo(name, path, this._context, ss);
ss.Internal.Module = info;
info.PrivateData = privateData;
bool flag = false;
int newValue = 0;
try
{
ScriptBlock scriptBlock;
this._context.EngineSessionState = ss.Internal;
ExternalScriptInfo scriptCommandInfo = moduleCode as ExternalScriptInfo;
if (scriptCommandInfo != null)
{
scriptBlock = scriptCommandInfo.ScriptBlock;
this._context.Debugger.RegisterScriptFile(scriptCommandInfo);
}
else
{
scriptBlock = moduleCode as ScriptBlock;
if (scriptBlock != null)
{
PSLanguageMode?languageMode = scriptBlock.LanguageMode;
scriptBlock = scriptBlock.Clone(true);
scriptBlock.LanguageMode = languageMode;
scriptBlock.SessionState = ss;
}
else if (moduleCode is string)
{
scriptBlock = ScriptBlock.Create(this._context, (string)moduleCode);
}
}
if (scriptBlock == null)
{
throw PSTraceSource.NewInvalidOperationException();
}
scriptBlock.SessionStateInternal = ss.Internal;
InvocationInfo invocationInfo = new InvocationInfo(scriptCommandInfo, scriptPosition);
info._definitionExtent = scriptBlock.Ast.Extent;
ArrayList resultList = new ArrayList();
try
{
Pipe outputPipe = new Pipe(resultList);
scriptBlock.InvokeWithPipe(false, ScriptBlock.ErrorHandlingBehavior.WriteToCurrentErrorPipe, AutomationNull.Value, AutomationNull.Value, AutomationNull.Value, outputPipe, invocationInfo, arguments ?? new object[0]);
}
catch (ExitException exception)
{
newValue = (int)exception.Argument;
flag = true;
}
result = resultList;
}
finally
{
this._context.EngineSessionState = engineSessionState;
}
if (flag)
{
this._context.SetVariable(SpecialVariables.LastExitCodeVarPath, newValue);
}
return(info);
}
internal void AddRequiredModule(PSModuleInfo requiredModule)
{
AddModuleToList(requiredModule, this._requiredModules);
}
internal void SetModule(PSModuleInfo module)
{
this._module = module;
}
internal void AddNestedModule(PSModuleInfo nestedModule)
{
AddModuleToList(nestedModule, this._nestedModules);
}
internal void PopulatePSModuleInfo(PSModuleInfo moduleInfo)
{
moduleInfo.SetModuleType(ModuleType.Cim);
moduleInfo.SetVersion(new Version(this.cmdletizationMetadata.Class.Version));
Hashtable hashtable = new Hashtable(StringComparer.OrdinalIgnoreCase);
hashtable.Add("ClassName", this.cmdletizationMetadata.Class.ClassName);
hashtable.Add("CmdletAdapter", this.objectModelWrapper);
Hashtable hashtable2 = new Hashtable(StringComparer.OrdinalIgnoreCase);
hashtable2.Add("CmdletsOverObjects", hashtable);
moduleInfo.PrivateData = hashtable2;
}
/// <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");
}
}
private static void AssociatePSModuleInfoWithSession(PSModuleInfo moduleInfo, object weaklyTypedSession)
{
s_moduleInfoToSession.Add(moduleInfo, weaklyTypedSession);
}
internal CmdletInfo(string name, Type implementingType, string helpFile, PSSnapInInfo snapin, PSModuleInfo module)
: base(name, CommandTypes.Cmdlet)
{
int i = name.IndexOf('-');
if (i == -1)
{
throw new Exception("InvalidCmdletNameFormat " + name);
}
ParameterInfoLookupTable = new Dictionary <string, CommandParameterInfo>(StringComparer.CurrentCultureIgnoreCase);
Verb = name.Substring(0, i);
Noun = name.Substring(i + 1);
ImplementingType = implementingType;
HelpFile = helpFile;
_validationException = null;
PSSnapIn = snapin;
Module = module;
GetParameterSetInfo(implementingType);
GetOutputTypes(implementingType);
}
private ScriptFile[] GetBuiltinCommandScriptFiles(
PSModuleInfo moduleInfo,
Workspace workspace)
{
// if there is module info for this command
if (moduleInfo != null)
{
string modPath = moduleInfo.Path;
List<ScriptFile> scriptFiles = new List<ScriptFile>();
ScriptFile newFile;
// find any files where the moduleInfo's path ends with ps1 or psm1
// and add it to allowed script files
if (modPath.EndsWith(@".ps1") || modPath.EndsWith(@".psm1"))
{
newFile = workspace.GetFile(modPath);
newFile.IsAnalysisEnabled = false;
scriptFiles.Add(newFile);
}
if (moduleInfo.NestedModules.Count > 0)
{
foreach (PSModuleInfo nestedInfo in moduleInfo.NestedModules)
{
string nestedModPath = nestedInfo.Path;
if (nestedModPath.EndsWith(@".ps1") || nestedModPath.EndsWith(@".psm1"))
{
newFile = workspace.GetFile(nestedModPath);
newFile.IsAnalysisEnabled = false;
scriptFiles.Add(newFile);
}
}
}
return scriptFiles.ToArray();
}
return new List<ScriptFile>().ToArray();
}
private List <PSModuleInfo> GetModuleCore(string[] patterns, bool all, bool exactMatch)
{
string str = null;
List <WildcardPattern> list = new List <WildcardPattern>();
if (exactMatch)
{
str = patterns[0];
}
else
{
if (patterns == null)
{
patterns = new string[] { "*" };
}
foreach (string str2 in patterns)
{
list.Add(new WildcardPattern(str2, WildcardOptions.IgnoreCase));
}
}
List <PSModuleInfo> list2 = new List <PSModuleInfo>();
if (all)
{
foreach (string str3 in this.ModuleTable.Keys)
{
PSModuleInfo item = this.ModuleTable[str3];
if ((exactMatch && item.Name.Equals(str, StringComparison.OrdinalIgnoreCase)) || (!exactMatch && SessionStateUtilities.MatchesAnyWildcardPattern(item.Name, list, false)))
{
list2.Add(item);
}
}
}
else
{
Dictionary <string, bool> dictionary = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase);
foreach (string str4 in this._context.EngineSessionState.ModuleTable.Keys)
{
PSModuleInfo info2 = this._context.EngineSessionState.ModuleTable[str4];
if ((exactMatch && info2.Name.Equals(str, StringComparison.OrdinalIgnoreCase)) || (!exactMatch && SessionStateUtilities.MatchesAnyWildcardPattern(info2.Name, list, false)))
{
list2.Add(info2);
dictionary[str4] = true;
}
}
if (this._context.EngineSessionState != this._context.TopLevelSessionState)
{
foreach (string str5 in this._context.TopLevelSessionState.ModuleTable.Keys)
{
if (!dictionary.ContainsKey(str5))
{
PSModuleInfo info3 = this.ModuleTable[str5];
if ((exactMatch && info3.Name.Equals(str, StringComparison.OrdinalIgnoreCase)) || (!exactMatch && SessionStateUtilities.MatchesAnyWildcardPattern(info3.Name, list, false)))
{
list2.Add(info3);
}
}
}
}
}
return((from m in list2
orderby m.Name
select m).ToList <PSModuleInfo>());
}
