private IEnumerable <PSModuleInfo> GetAvailableViaCimSessionCore(IEnumerable <string> moduleNames, Microsoft.Management.Infrastructure.CimSession cimSession, Uri resourceUri, string cimNamespace)
{
return(from cimModule in RemoteDiscoveryHelper.GetCimModules(cimSession, resourceUri, cimNamespace, moduleNames, true, this, this.CancellationToken)
select this.ConvertCimModuleInfoToPSModuleInfo(cimModule, cimSession.ComputerName) into moduleInfo
where moduleInfo != null
select moduleInfo);
}
private IEnumerable<string> CreateCimModuleFiles(RemoteDiscoveryHelper.CimModule remoteCimModule, RemoteDiscoveryHelper.CimFileCode fileCode, Func<RemoteDiscoveryHelper.CimModuleFile, bool> filesFilter, string temporaryModuleDirectory)
{
string format = null;
switch (fileCode)
{
case RemoteDiscoveryHelper.CimFileCode.TypesV1:
format = "{0}_{1}.types.ps1xml";
break;
case RemoteDiscoveryHelper.CimFileCode.FormatV1:
format = "{0}_{1}.format.ps1xml";
break;
case RemoteDiscoveryHelper.CimFileCode.CmdletizationV1:
format = "{0}_{1}.cdxml";
break;
}
List<string> list = new List<string>();
foreach (RemoteDiscoveryHelper.CimModuleFile file in remoteCimModule.ModuleFiles)
{
if (filesFilter(file))
{
string fileName = Path.GetFileName(file.FileName);
string item = string.Format(CultureInfo.InvariantCulture, format, new object[] { fileName.Substring(0, Math.Min(fileName.Length, 20)), Path.GetRandomFileName() });
list.Add(item);
string path = Path.Combine(temporaryModuleDirectory, item);
File.WriteAllBytes(path, file.RawFileData);
AlternateDataStreamUtilities.SetZoneOfOrigin(path, SecurityZone.Intranet);
}
}
return list;
}
private IEnumerable <PSModuleInfo> GetAvailableViaPsrpSessionCore(string[] moduleNames, Runspace remoteRunspace)
{
Dbg.Assert(remoteRunspace != null, "Caller should verify remoteRunspace != null");
using (var powerShell = System.Management.Automation.PowerShell.Create())
{
powerShell.Runspace = remoteRunspace;
powerShell.AddCommand("Get-Module");
powerShell.AddParameter("ListAvailable", true);
if (Refresh.IsPresent)
{
powerShell.AddParameter("Refresh", true);
}
if (moduleNames != null)
{
powerShell.AddParameter("Name", moduleNames);
}
string errorMessageTemplate = string.Format(
CultureInfo.InvariantCulture,
Modules.RemoteDiscoveryRemotePsrpCommandFailed,
"Get-Module");
foreach (
PSObject outputObject in
RemoteDiscoveryHelper.InvokePowerShell(powerShell, this, errorMessageTemplate,
this.CancellationToken))
{
PSModuleInfo moduleInfo = RemoteDiscoveryHelper.RehydratePSModuleInfo(outputObject);
yield return(moduleInfo);
}
}
}
private void GetAvailableViaPsrpSession(string[] moduleNames, System.Management.Automation.Runspaces.PSSession session)
{
foreach (PSModuleInfo info in this.GetAvailableViaPsrpSessionCore(moduleNames, session.Runspace))
{
RemoteDiscoveryHelper.AssociatePSModuleInfoWithSession(info, session);
base.WriteObject(info);
}
}
private void GetAvailableViaCimSession(string[] moduleNames, Microsoft.Management.Infrastructure.CimSession cimSession, Uri resourceUri, string cimNamespace)
{
foreach (PSModuleInfo info in this.GetAvailableViaCimSessionCore(moduleNames, cimSession, resourceUri, cimNamespace))
{
RemoteDiscoveryHelper.AssociatePSModuleInfoWithSession(info, cimSession, resourceUri, cimNamespace);
base.WriteObject(info);
}
}
private void GetAvailableViaPsrpSession(string[] names, IDictionary <string, ModuleSpecification> moduleSpecTable, PSSession session)
{
IEnumerable <PSModuleInfo> remoteModules = GetAvailableViaPsrpSessionCore(names, session.Runspace);
foreach (PSModuleInfo remoteModule in FilterModulesForEditionAndSpecification(remoteModules, moduleSpecTable))
{
RemoteDiscoveryHelper.AssociatePSModuleInfoWithSession(remoteModule, session);
this.WriteObject(remoteModule);
}
}
private void GetAvailableViaPsrpSession(string[] names, IDictionary<string, ModuleSpecification> moduleSpecTable, PSSession session)
{
var remoteModules = GetAvailableViaPsrpSessionCore(names, session.Runspace);
foreach (var remoteModule in remoteModules.Where(remoteModule => ModuleMatch(remoteModule, moduleSpecTable, PSEdition))
)
{
RemoteDiscoveryHelper.AssociatePSModuleInfoWithSession(remoteModule, session);
this.WriteObject(remoteModule);
}
}
private void GetAvailableViaCimSession(IEnumerable <string> names, IDictionary <string, ModuleSpecification> moduleSpecTable,
CimSession cimSession, Uri resourceUri, string cimNamespace)
{
IEnumerable <PSModuleInfo> remoteModules = GetAvailableViaCimSessionCore(names, cimSession, resourceUri, cimNamespace);
foreach (PSModuleInfo remoteModule in FilterModulesForEditionAndSpecification(remoteModules, moduleSpecTable))
{
RemoteDiscoveryHelper.AssociatePSModuleInfoWithSession(remoteModule, cimSession, resourceUri,
cimNamespace);
this.WriteObject(remoteModule);
}
}
private void GetAvailableViaCimSession(IEnumerable<string> names, IDictionary<string, ModuleSpecification> moduleSpecTable,
CimSession cimSession, Uri resourceUri, string cimNamespace)
{
var remoteModules = GetAvailableViaCimSessionCore(names, cimSession, resourceUri, cimNamespace);
foreach (var remoteModule in remoteModules.Where(remoteModule => ModuleMatch(remoteModule, moduleSpecTable, PSEdition))
)
{
RemoteDiscoveryHelper.AssociatePSModuleInfoWithSession(remoteModule, cimSession, resourceUri,
cimNamespace);
this.WriteObject(remoteModule);
}
}
private IEnumerable <PSModuleInfo> GetAvailableViaCimSessionCore(IEnumerable <string> moduleNames,
CimSession cimSession, Uri resourceUri,
string cimNamespace)
{
IEnumerable <RemoteDiscoveryHelper.CimModule> remoteModules = RemoteDiscoveryHelper.GetCimModules(
cimSession,
resourceUri,
cimNamespace,
moduleNames,
true /* onlyManifests */,
this,
this.CancellationToken);
IEnumerable <PSModuleInfo> remoteModuleInfos = remoteModules
.Select(cimModule => this.ConvertCimModuleInfoToPSModuleInfo(cimModule, cimSession.ComputerName))
.Where(static moduleInfo => moduleInfo != null);
private PSModuleInfo ConvertCimModuleInfoToPSModuleInfo(RemoteDiscoveryHelper.CimModule cimModule, string computerName)
{
try
{
bool containedErrors = false;
if (cimModule.MainManifest == null)
{
return(this.GetModuleInfoForRemoteModuleWithoutManifest(cimModule));
}
string temporaryModuleManifestPath = Path.Combine(RemoteDiscoveryHelper.GetModulePath(cimModule.ModuleName, null, computerName, base.Context.CurrentRunspace), Path.GetFileName(cimModule.ModuleName));
Hashtable originalManifest = null;
if (!containedErrors)
{
originalManifest = RemoteDiscoveryHelper.ConvertCimModuleFileToManifestHashtable(cimModule.MainManifest, temporaryModuleManifestPath, this, ref containedErrors);
if (originalManifest == null)
{
return(this.GetModuleInfoForRemoteModuleWithoutManifest(cimModule));
}
}
if (!containedErrors)
{
originalManifest = RemoteDiscoveryHelper.RewriteManifest(originalManifest);
}
Hashtable localizedData = originalManifest;
PSModuleInfo moduleInfoForRemoteModuleWithoutManifest = null;
if (!containedErrors)
{
ModuleCmdletBase.ImportModuleOptions options = new ModuleCmdletBase.ImportModuleOptions();
moduleInfoForRemoteModuleWithoutManifest = base.LoadModuleManifest(temporaryModuleManifestPath, null, originalManifest, localizedData, 0, base.BaseMinimumVersion, base.BaseRequiredVersion, ref options, ref containedErrors);
}
if ((moduleInfoForRemoteModuleWithoutManifest == null) || containedErrors)
{
moduleInfoForRemoteModuleWithoutManifest = this.GetModuleInfoForRemoteModuleWithoutManifest(cimModule);
}
return(moduleInfoForRemoteModuleWithoutManifest);
}
catch (Exception exception)
{
ErrorRecord errorRecordForProcessingOfCimModule = RemoteDiscoveryHelper.GetErrorRecordForProcessingOfCimModule(exception, cimModule.ModuleName);
base.WriteError(errorRecordForProcessingOfCimModule);
return(null);
}
}
private PSModuleInfo ConvertCimModuleInfoToPSModuleInfo(RemoteDiscoveryHelper.CimModule cimModule, string computerName)
{
try
{
bool containedErrors = false;
if (cimModule.MainManifest == null)
{
return this.GetModuleInfoForRemoteModuleWithoutManifest(cimModule);
}
string temporaryModuleManifestPath = Path.Combine(RemoteDiscoveryHelper.GetModulePath(cimModule.ModuleName, null, computerName, base.Context.CurrentRunspace), Path.GetFileName(cimModule.ModuleName));
Hashtable originalManifest = null;
if (!containedErrors)
{
originalManifest = RemoteDiscoveryHelper.ConvertCimModuleFileToManifestHashtable(cimModule.MainManifest, temporaryModuleManifestPath, this, ref containedErrors);
if (originalManifest == null)
{
return this.GetModuleInfoForRemoteModuleWithoutManifest(cimModule);
}
}
if (!containedErrors)
{
originalManifest = RemoteDiscoveryHelper.RewriteManifest(originalManifest);
}
Hashtable localizedData = originalManifest;
PSModuleInfo moduleInfoForRemoteModuleWithoutManifest = null;
if (!containedErrors)
{
ModuleCmdletBase.ImportModuleOptions options = new ModuleCmdletBase.ImportModuleOptions();
moduleInfoForRemoteModuleWithoutManifest = base.LoadModuleManifest(temporaryModuleManifestPath, null, originalManifest, localizedData, 0, base.BaseMinimumVersion, base.BaseRequiredVersion, ref options, ref containedErrors);
}
if ((moduleInfoForRemoteModuleWithoutManifest == null) || containedErrors)
{
moduleInfoForRemoteModuleWithoutManifest = this.GetModuleInfoForRemoteModuleWithoutManifest(cimModule);
}
return moduleInfoForRemoteModuleWithoutManifest;
}
catch (Exception exception)
{
ErrorRecord errorRecordForProcessingOfCimModule = RemoteDiscoveryHelper.GetErrorRecordForProcessingOfCimModule(exception, cimModule.ModuleName);
base.WriteError(errorRecordForProcessingOfCimModule);
return null;
}
}
private IEnumerable <PSModuleInfo> GetAvailableViaPsrpSessionCore(string[] moduleNames, Runspace remoteRunspace)
{
using (PowerShell iteratorVariable0 = PowerShell.Create())
{
iteratorVariable0.Runspace = remoteRunspace;
iteratorVariable0.AddCommand("Get-Module");
iteratorVariable0.AddParameter("ListAvailable", true);
if (this.Refresh.IsPresent)
{
iteratorVariable0.AddParameter("Refresh", true);
}
if (moduleNames != null)
{
iteratorVariable0.AddParameter("Name", moduleNames);
}
string errorMessageTemplate = string.Format(CultureInfo.InvariantCulture, Modules.RemoteDiscoveryRemotePsrpCommandFailed, new object[] { "Get-Module" });
foreach (PSObject iteratorVariable2 in RemoteDiscoveryHelper.InvokePowerShell(iteratorVariable0, this.CancellationToken, this, errorMessageTemplate))
{
PSModuleInfo iteratorVariable3 = RemoteDiscoveryHelper.RehydratePSModuleInfo(iteratorVariable2);
yield return(iteratorVariable3);
}
}
}
private PSModuleInfo GetModuleInfoForRemoteModuleWithoutManifest(RemoteDiscoveryHelper.CimModule cimModule)
{
return new PSModuleInfo(cimModule.ModuleName, null, null);
}
private bool IsMixedModePsCimModule(RemoteDiscoveryHelper.CimModule cimModule)
{
string temporaryModuleManifestPath = RemoteDiscoveryHelper.GetModulePath(cimModule.ModuleName, null, string.Empty, base.Context.CurrentRunspace);
bool containedErrors = false;
RemoteDiscoveryHelper.CimModuleFile mainManifest = cimModule.MainManifest;
if (mainManifest == null)
{
return true;
}
Hashtable manifestData = RemoteDiscoveryHelper.ConvertCimModuleFileToManifestHashtable(mainManifest, temporaryModuleManifestPath, this, ref containedErrors);
if (containedErrors || (manifestData == null))
{
return false;
}
if (IsNonEmptyManifestField(manifestData, "ScriptsToProcess") || IsNonEmptyManifestField(manifestData, "RequiredAssemblies"))
{
return true;
}
int num = 0;
string[] result = null;
if (LanguagePrimitives.TryConvertTo<string[]>(manifestData["NestedModules"], CultureInfo.InvariantCulture, out result) && (result != null))
{
num += result.Length;
}
if (manifestData.ContainsKey("RootModule") || manifestData.ContainsKey("ModuleToProcess"))
{
if (manifestData.ContainsKey("RootModule"))
{
string str2;
if (LanguagePrimitives.TryConvertTo<string>(manifestData["RootModule"], CultureInfo.InvariantCulture, out str2) && !string.IsNullOrEmpty(str2))
{
num++;
}
}
else
{
string str3;
if ((manifestData.ContainsKey("ModuleToProcess") && LanguagePrimitives.TryConvertTo<string>(manifestData["ModuleToProcess"], CultureInfo.InvariantCulture, out str3)) && !string.IsNullOrEmpty(str3))
{
num++;
}
}
}
int num2 = (from moduleFile in cimModule.ModuleFiles
where moduleFile.FileCode == RemoteDiscoveryHelper.CimFileCode.CmdletizationV1
select moduleFile).Count<RemoteDiscoveryHelper.CimModuleFile>();
return (num > num2);
}
private PSModuleInfo ConvertCimModuleInfoToPSModuleInfo(RemoteDiscoveryHelper.CimModule cimModule,
string computerName)
{
try
{
bool containedErrors = false;
if (cimModule.MainManifest == 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 == 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 == null) || containedErrors)
{
moduleInfo = GetModuleInfoForRemoteModuleWithoutManifest(cimModule);
}
return(moduleInfo);
}
catch (Exception e)
{
ErrorRecord errorRecord = RemoteDiscoveryHelper.GetErrorRecordForProcessingOfCimModule(e, cimModule.ModuleName);
this.WriteError(errorRecord);
return(null);
}
}
private PSModuleInfo ImportModule_RemotelyViaCimModuleData(
ImportModuleOptions importModuleOptions,
RemoteDiscoveryHelper.CimModule remoteCimModule,
CimSession cimSession)
{
try
{
if (remoteCimModule.MainManifest == null)
{
string errorMessage = string.Format(
CultureInfo.InvariantCulture,
Modules.EmptyModuleManifest,
remoteCimModule.ModuleName + ".psd1");
ArgumentException argumentException = new ArgumentException(errorMessage);
throw argumentException;
}
bool containedErrors = false;
PSModuleInfo moduleInfo = null;
//
// read the original manifest
//
string temporaryModuleDirectory = RemoteDiscoveryHelper.GetModulePath(
remoteCimModule.ModuleName,
null,
cimSession.ComputerName,
this.Context.CurrentRunspace);
string temporaryModuleManifestPath = Path.Combine(
temporaryModuleDirectory,
remoteCimModule.ModuleName + ".psd1");
Hashtable data = null;
Hashtable localizedData = null;
{
ScriptBlockAst scriptBlockAst = null;
Token[] throwAwayTokens;
ParseError[] parseErrors;
scriptBlockAst = Parser.ParseInput(
remoteCimModule.MainManifest.FileData,
temporaryModuleManifestPath,
out throwAwayTokens,
out parseErrors);
if ((scriptBlockAst == null) ||
(parseErrors != null && parseErrors.Length > 0))
{
throw new ParseException(parseErrors);
}
ScriptBlock scriptBlock = new ScriptBlock(scriptBlockAst, isFilter: false);
data = LoadModuleManifestData(
temporaryModuleManifestPath,
scriptBlock,
ModuleManifestMembers,
ManifestProcessingFlags.NullOnFirstError | ManifestProcessingFlags.WriteErrors, /* - don't load elements */
ref containedErrors);
if ((data == null) || containedErrors)
{
return null;
}
localizedData = data;
}
//
// flatten module contents and rewrite the manifest to point to the flattened file hierarchy
//
// recalculate module path, taking into account the module version fetched above
Version moduleVersion;
if (!GetScalarFromData<Version>(data, null, "ModuleVersion", 0, out moduleVersion))
{
moduleVersion = null;
}
temporaryModuleDirectory = RemoteDiscoveryHelper.GetModulePath(
remoteCimModule.ModuleName,
moduleVersion,
cimSession.ComputerName,
this.Context.CurrentRunspace);
temporaryModuleManifestPath = Path.Combine(
temporaryModuleDirectory,
remoteCimModule.ModuleName + ".psd1");
// avoid loading an already loaded module
PSModuleInfo alreadyImportedModule = this.IsModuleImportUnnecessaryBecauseModuleIsAlreadyLoaded(
temporaryModuleManifestPath, this.BasePrefix, importModuleOptions);
if (alreadyImportedModule != null)
{
return alreadyImportedModule;
}
try
{
Directory.CreateDirectory(temporaryModuleDirectory);
IEnumerable<string> typesToProcess = CreateCimModuleFiles(
remoteCimModule,
RemoteDiscoveryHelper.CimFileCode.TypesV1,
cimModuleFile => IsTypesPs1XmlFile(cimModuleFile, data),
temporaryModuleDirectory);
IEnumerable<string> formatsToProcess = CreateCimModuleFiles(
remoteCimModule,
RemoteDiscoveryHelper.CimFileCode.FormatV1,
cimModuleFile => IsFormatPs1XmlFile(cimModuleFile, data),
temporaryModuleDirectory);
IEnumerable<string> nestedModules = CreateCimModuleFiles(
remoteCimModule,
RemoteDiscoveryHelper.CimFileCode.CmdletizationV1,
IsCmdletizationFile,
temporaryModuleDirectory);
data = RemoteDiscoveryHelper.RewriteManifest(
data,
nestedModules: nestedModules,
typesToProcess: typesToProcess,
formatsToProcess: formatsToProcess);
localizedData = RemoteDiscoveryHelper.RewriteManifest(localizedData);
//
// import the module
// (from memory - this avoids the authenticode signature problems
// that would be introduced by rewriting the contents of the manifest)
//
moduleInfo = LoadModuleManifest(
temporaryModuleManifestPath,
null, //scriptInfo
data,
localizedData,
ManifestProcessingFlags.LoadElements | ManifestProcessingFlags.WriteErrors | ManifestProcessingFlags.NullOnFirstError,
BaseMinimumVersion,
BaseMaximumVersion,
BaseRequiredVersion,
BaseGuid,
ref importModuleOptions,
ref containedErrors);
if (moduleInfo == null)
{
return null;
}
foreach (PSModuleInfo nestedModule in moduleInfo.NestedModules)
{
Type cmdletAdapter;
bool gotCmdletAdapter = PSPrimitiveDictionary.TryPathGet(
nestedModule.PrivateData as IDictionary,
out cmdletAdapter,
"CmdletsOverObjects",
"CmdletAdapter");
Dbg.Assert(gotCmdletAdapter, "PrivateData from cdxml should always include cmdlet adapter");
if (!cmdletAdapter.AssemblyQualifiedName.Equals(StringLiterals.DefaultCmdletAdapter, StringComparison.OrdinalIgnoreCase))
{
string errorMessage = string.Format(
CultureInfo.InvariantCulture,
CmdletizationCoreResources.ImportModule_UnsupportedCmdletAdapter,
cmdletAdapter.FullName);
ErrorRecord errorRecord = new ErrorRecord(
new InvalidOperationException(errorMessage),
"UnsupportedCmdletAdapter",
ErrorCategory.InvalidData,
cmdletAdapter);
this.ThrowTerminatingError(errorRecord);
}
}
if (IsMixedModePsCimModule(remoteCimModule))
{
// warn that some commands have not been imported
string warningMessage = string.Format(
CultureInfo.InvariantCulture,
Modules.MixedModuleOverCimSessionWarning,
remoteCimModule.ModuleName);
this.WriteWarning(warningMessage);
}
//
// store the default session
//
Dbg.Assert(moduleInfo.ModuleType == ModuleType.Manifest, "Remote discovery should always produce a 'manifest' module");
Dbg.Assert(moduleInfo.NestedModules != null, "Remote discovery should always produce a 'manifest' module with nested modules entry");
Dbg.Assert(moduleInfo.NestedModules.Count > 0, "Remote discovery should always produce a 'manifest' module with some nested modules");
foreach (PSModuleInfo nestedModule in moduleInfo.NestedModules)
{
IDictionary cmdletsOverObjectsPrivateData;
bool cmdletsOverObjectsPrivateDataWasFound = PSPrimitiveDictionary.TryPathGet<IDictionary>(
nestedModule.PrivateData as IDictionary,
out cmdletsOverObjectsPrivateData,
ScriptWriter.PrivateDataKey_CmdletsOverObjects);
Dbg.Assert(cmdletsOverObjectsPrivateDataWasFound, "Cmdletization should always set the PrivateData properly");
cmdletsOverObjectsPrivateData[ScriptWriter.PrivateDataKey_DefaultSession] = cimSession;
}
//
// make sure the temporary folder gets removed when the module is removed
//
const string onRemoveScriptBody =
@"
Microsoft.PowerShell.Management\Remove-Item `
-LiteralPath $temporaryModulePath `
-Force `
-Recurse `
-ErrorAction SilentlyContinue
if ($previousOnRemoveScript -ne $null)
{
& $previousOnRemoveScript $args
}
";
ScriptBlock onRemoveScriptBlock = this.Context.Engine.ParseScriptBlock(onRemoveScriptBody, false);
onRemoveScriptBlock = onRemoveScriptBlock.GetNewClosure();
// create a separate scope for variables set below
onRemoveScriptBlock.Module.SessionState.PSVariable.Set("temporaryModulePath", temporaryModuleDirectory);
onRemoveScriptBlock.Module.SessionState.PSVariable.Set("previousOnRemoveScript", moduleInfo.OnRemove);
moduleInfo.OnRemove = onRemoveScriptBlock;
//
// Some processing common for local and remote modules
//
AddModuleToModuleTables(
this.Context,
this.TargetSessionState.Internal,
moduleInfo);
if (BasePassThru)
{
WriteObject(moduleInfo);
}
return moduleInfo;
}
catch
{
if (Directory.Exists(temporaryModuleDirectory))
{
Directory.Delete(temporaryModuleDirectory, recursive: true);
}
throw;
}
finally
{
if (moduleInfo == null)
{
if (Directory.Exists(temporaryModuleDirectory))
{
Directory.Delete(temporaryModuleDirectory, recursive: true);
}
}
}
}
catch (Exception e)
{
ErrorRecord errorRecord = RemoteDiscoveryHelper.GetErrorRecordForProcessingOfCimModule(e, remoteCimModule.ModuleName);
this.WriteError(errorRecord);
return null;
}
}
private IEnumerable<string> CreateCimModuleFiles(
RemoteDiscoveryHelper.CimModule remoteCimModule,
RemoteDiscoveryHelper.CimFileCode fileCode,
Func<RemoteDiscoveryHelper.CimModuleFile, bool> filesFilter,
string temporaryModuleDirectory)
{
string fileNameTemplate = null;
switch (fileCode)
{
case RemoteDiscoveryHelper.CimFileCode.CmdletizationV1:
fileNameTemplate = "{0}_{1}.cdxml";
break;
case RemoteDiscoveryHelper.CimFileCode.TypesV1:
fileNameTemplate = "{0}_{1}.types.ps1xml";
break;
case RemoteDiscoveryHelper.CimFileCode.FormatV1:
fileNameTemplate = "{0}_{1}.format.ps1xml";
break;
default:
Dbg.Assert(false, "Unrecognized file code");
break;
}
List<string> relativePathsToCreatedFiles = new List<string>();
foreach (RemoteDiscoveryHelper.CimModuleFile file in remoteCimModule.ModuleFiles)
{
if (!filesFilter(file))
{
continue;
}
string originalFileName = Path.GetFileName(file.FileName);
string fileName = string.Format(
CultureInfo.InvariantCulture,
fileNameTemplate,
originalFileName.Substring(0, Math.Min(originalFileName.Length, 20)),
Path.GetRandomFileName());
relativePathsToCreatedFiles.Add(fileName);
string fullPath = Path.Combine(temporaryModuleDirectory, fileName);
File.WriteAllBytes(
fullPath,
file.RawFileData);
AlternateDataStreamUtilities.SetZoneOfOrigin(fullPath, SecurityZone.Intranet);
}
return relativePathsToCreatedFiles;
}
private static bool IsCmdletizationFile(RemoteDiscoveryHelper.CimModuleFile cimModuleFile)
{
return cimModuleFile.FileCode == RemoteDiscoveryHelper.CimFileCode.CmdletizationV1;
}
private bool IsFormatPs1XmlFile(RemoteDiscoveryHelper.CimModuleFile cimModuleFile, Hashtable manifestData)
{
return IsPs1xmlFileHelper(cimModuleFile, manifestData, goodKey: "FormatsToProcess", badKey: "TypesToProcess");
}
private bool IsPs1xmlFileHelper(RemoteDiscoveryHelper.CimModuleFile cimModuleFile, Hashtable manifestData, string goodKey, string badKey)
{
if (!Path.GetExtension(cimModuleFile.FileName).Equals(".ps1xml", StringComparison.OrdinalIgnoreCase))
{
return false;
}
List<string> goodEntries;
if (!this.GetListOfStringsFromData(manifestData, null, goodKey, 0, out goodEntries))
{
goodEntries = new List<string>();
}
if (goodEntries == null)
{
goodEntries = new List<string>();
}
List<string> badEntries;
if (!this.GetListOfStringsFromData(manifestData, null, badKey, 0, out badEntries))
{
badEntries = new List<string>();
}
if (badEntries == null)
{
badEntries = new List<string>();
}
bool presentInGoodEntries = IsPs1xmlFileHelper_IsPresentInEntries(cimModuleFile, goodEntries);
bool presentInBadEntries = IsPs1xmlFileHelper_IsPresentInEntries(cimModuleFile, badEntries);
return presentInGoodEntries && !presentInBadEntries;
}
private bool IsPs1xmlFileHelper_IsPresentInEntries(RemoteDiscoveryHelper.CimModuleFile cimModuleFile, IEnumerable<string> manifestEntries)
{
if (manifestEntries.Any(s => s.EndsWith(cimModuleFile.FileName, StringComparison.OrdinalIgnoreCase)))
{
return true;
}
if (manifestEntries.Any(s => FixupFileName("", s, ".ps1xml").EndsWith(cimModuleFile.FileName, StringComparison.OrdinalIgnoreCase)))
{
return true;
}
return false;
}
private bool IsMixedModePsCimModule(RemoteDiscoveryHelper.CimModule cimModule)
{
string temporaryModuleManifestPath = RemoteDiscoveryHelper.GetModulePath(cimModule.ModuleName, null, string.Empty, this.Context.CurrentRunspace);
bool containedErrors = false;
RemoteDiscoveryHelper.CimModuleFile mainManifestFile = cimModule.MainManifest;
if (mainManifestFile == null)
{
return true;
}
Hashtable manifestData = RemoteDiscoveryHelper.ConvertCimModuleFileToManifestHashtable(
mainManifestFile,
temporaryModuleManifestPath,
this,
ref containedErrors);
if (containedErrors || manifestData == null)
{
return false;
}
if (IsNonEmptyManifestField(manifestData, "ScriptsToProcess") ||
IsNonEmptyManifestField(manifestData, "RequiredAssemblies"))
{
return true;
}
int numberOfSubmodules = 0;
string[] nestedModules = null;
if (LanguagePrimitives.TryConvertTo(manifestData["NestedModules"], CultureInfo.InvariantCulture, out nestedModules))
{
if (nestedModules != null)
{
numberOfSubmodules += nestedModules.Length;
}
}
object rootModuleValue = manifestData["RootModule"];
if (rootModuleValue != null)
{
string rootModule;
if (LanguagePrimitives.TryConvertTo(rootModuleValue, CultureInfo.InvariantCulture, out rootModule))
{
if (!string.IsNullOrEmpty(rootModule))
{
numberOfSubmodules += 1;
}
}
}
else
{
object moduleToProcessValue = manifestData["ModuleToProcess"];
string moduleToProcess;
if (moduleToProcessValue != null && LanguagePrimitives.TryConvertTo(moduleToProcessValue, CultureInfo.InvariantCulture, out moduleToProcess))
{
if (!string.IsNullOrEmpty(moduleToProcess))
{
numberOfSubmodules += 1;
}
}
}
int numberOfCmdletizationFiles = 0;
foreach (var moduleFile in cimModule.ModuleFiles)
{
if (moduleFile.FileCode == RemoteDiscoveryHelper.CimFileCode.CmdletizationV1)
numberOfCmdletizationFiles++;
}
bool isMixedModePsCimModule = numberOfSubmodules > numberOfCmdletizationFiles;
return isMixedModePsCimModule;
}
private bool IsPs1xmlFileHelper(RemoteDiscoveryHelper.CimModuleFile cimModuleFile, Hashtable manifestData, string goodKey, string badKey)
{
List<string> list;
List<string> list2;
if (!Path.GetExtension(cimModuleFile.FileName).Equals(".ps1xml", StringComparison.OrdinalIgnoreCase))
{
return false;
}
if (!base.GetListOfStringsFromData(manifestData, null, goodKey, 0, out list))
{
list = new List<string>();
}
if (list == null)
{
list = new List<string>();
}
if (!base.GetListOfStringsFromData(manifestData, null, badKey, 0, out list2))
{
list2 = new List<string>();
}
if (list2 == null)
{
list2 = new List<string>();
}
bool flag = this.IsPs1xmlFileHelper_IsPresentInEntries(cimModuleFile, list);
bool flag2 = this.IsPs1xmlFileHelper_IsPresentInEntries(cimModuleFile, list2);
return (flag && !flag2);
}
private bool IsTypesPs1XmlFile(RemoteDiscoveryHelper.CimModuleFile cimModuleFile, Hashtable manifestData)
{
return this.IsPs1xmlFileHelper(cimModuleFile, manifestData, "TypesToProcess", "FormatsToProcess");
}
private PSModuleInfo ConvertCimModuleInfoToPSModuleInfo(RemoteDiscoveryHelper.CimModule cimModule,
string computerName)
{
try
{
bool containedErrors = false;
if (cimModule.MainManifest == 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 == 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 == null) || containedErrors)
{
moduleInfo = GetModuleInfoForRemoteModuleWithoutManifest(cimModule);
}
return moduleInfo;
}
catch (Exception e)
{
ErrorRecord errorRecord = RemoteDiscoveryHelper.GetErrorRecordForProcessingOfCimModule(e, cimModule.ModuleName);
this.WriteError(errorRecord);
return null;
}
}
private PSModuleInfo ImportModule_RemotelyViaCimModuleData(ModuleCmdletBase.ImportModuleOptions importModuleOptions, RemoteDiscoveryHelper.CimModule remoteCimModule, Microsoft.Management.Infrastructure.CimSession cimSession)
{
PSModuleInfo info5;
try
{
Token[] tokenArray;
ParseError[] errorArray;
Version version;
Func<RemoteDiscoveryHelper.CimModuleFile, bool> filesFilter = null;
Func<RemoteDiscoveryHelper.CimModuleFile, bool> func2 = null;
if (remoteCimModule.MainManifest == null)
{
ArgumentException exception = new ArgumentException(string.Format(CultureInfo.InvariantCulture, Modules.EmptyModuleManifest, new object[] { remoteCimModule.ModuleName + ".psd1" }));
throw exception;
}
bool containedErrors = false;
PSModuleInfo module = null;
string fileName = Path.Combine(RemoteDiscoveryHelper.GetModulePath(remoteCimModule.ModuleName, null, cimSession.ComputerName, base.Context.CurrentRunspace), remoteCimModule.ModuleName + ".psd1");
Hashtable data = null;
Hashtable originalManifest = null;
ScriptBlockAst ast = null;
ast = Parser.ParseInput(remoteCimModule.MainManifest.FileData, fileName, out tokenArray, out errorArray);
if ((ast == null) || ((errorArray != null) && (errorArray.Length > 0)))
{
throw new ParseException(errorArray);
}
ScriptBlock scriptBlock = new ScriptBlock(ast, false);
data = base.LoadModuleManifestData(fileName, scriptBlock, ModuleCmdletBase.ModuleManifestMembers, ModuleCmdletBase.ManifestProcessingFlags.NullOnFirstError | ModuleCmdletBase.ManifestProcessingFlags.WriteErrors, ref containedErrors);
if ((data == null) || containedErrors)
{
return null;
}
originalManifest = data;
if (!base.GetScalarFromData<Version>(data, null, "ModuleVersion", 0, out version))
{
version = null;
}
string str2 = RemoteDiscoveryHelper.GetModulePath(remoteCimModule.ModuleName, version, cimSession.ComputerName, base.Context.CurrentRunspace);
fileName = Path.Combine(str2, remoteCimModule.ModuleName + ".psd1");
PSModuleInfo info2 = base.IsModuleImportUnnecessaryBecauseModuleIsAlreadyLoaded(fileName, base.BasePrefix, importModuleOptions);
if (info2 != null)
{
info5 = info2;
}
else
{
try
{
Directory.CreateDirectory(str2);
if (filesFilter == null)
{
filesFilter = cimModuleFile => this.IsTypesPs1XmlFile(cimModuleFile, data);
}
IEnumerable<string> typesToProcess = this.CreateCimModuleFiles(remoteCimModule, RemoteDiscoveryHelper.CimFileCode.TypesV1, filesFilter, str2);
if (func2 == null)
{
func2 = cimModuleFile => this.IsFormatPs1XmlFile(cimModuleFile, data);
}
IEnumerable<string> formatsToProcess = this.CreateCimModuleFiles(remoteCimModule, RemoteDiscoveryHelper.CimFileCode.FormatV1, func2, str2);
IEnumerable<string> nestedModules = this.CreateCimModuleFiles(remoteCimModule, RemoteDiscoveryHelper.CimFileCode.CmdletizationV1, new Func<RemoteDiscoveryHelper.CimModuleFile, bool>(ImportModuleCommand.IsCmdletizationFile), str2);
data = RemoteDiscoveryHelper.RewriteManifest(data, nestedModules, typesToProcess, formatsToProcess);
originalManifest = RemoteDiscoveryHelper.RewriteManifest(originalManifest);
module = base.LoadModuleManifest(fileName, null, data, originalManifest, ModuleCmdletBase.ManifestProcessingFlags.LoadElements | ModuleCmdletBase.ManifestProcessingFlags.NullOnFirstError | ModuleCmdletBase.ManifestProcessingFlags.WriteErrors, base.BaseMinimumVersion, base.BaseRequiredVersion, ref importModuleOptions, ref containedErrors);
if (module == null)
{
return null;
}
foreach (PSModuleInfo info3 in module.NestedModules)
{
Type type;
PSPrimitiveDictionary.TryPathGet<Type>(info3.PrivateData as IDictionary, out type, new string[] { "CmdletsOverObjects", "CmdletAdapter" });
if (!type.AssemblyQualifiedName.Equals("Microsoft.PowerShell.Cmdletization.Cim.CimCmdletAdapter, Microsoft.PowerShell.Commands.Management, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35", StringComparison.OrdinalIgnoreCase))
{
ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, CmdletizationCoreResources.ImportModule_UnsupportedCmdletAdapter, new object[] { type.FullName })), "UnsupportedCmdletAdapter", ErrorCategory.InvalidData, type);
base.ThrowTerminatingError(errorRecord);
}
}
if (this.IsMixedModePsCimModule(remoteCimModule))
{
string text = string.Format(CultureInfo.InvariantCulture, Modules.MixedModuleOverCimSessionWarning, new object[] { remoteCimModule.ModuleName });
base.WriteWarning(text);
}
foreach (PSModuleInfo info4 in module.NestedModules)
{
IDictionary dictionary;
PSPrimitiveDictionary.TryPathGet<IDictionary>(info4.PrivateData as IDictionary, out dictionary, new string[] { "CmdletsOverObjects" });
dictionary["DefaultSession"] = cimSession;
}
ScriptBlock newClosure = base.Context.Engine.ParseScriptBlock("\r\n Microsoft.PowerShell.Management\\Remove-Item `\r\n -LiteralPath $temporaryModulePath `\r\n -Force `\r\n -Recurse `\r\n -ErrorAction SilentlyContinue\r\n\r\n if ($previousOnRemoveScript -ne $null)\r\n {\r\n & $previousOnRemoveScript $args\r\n }\r\n ", false).GetNewClosure();
newClosure.Module.SessionState.PSVariable.Set("temporaryModulePath", str2);
newClosure.Module.SessionState.PSVariable.Set("previousOnRemoveScript", module.OnRemove);
module.OnRemove = newClosure;
ModuleCmdletBase.AddModuleToModuleTables(base.Context, base.TargetSessionState.Internal, module);
if (base.BasePassThru)
{
base.WriteObject(module);
}
info5 = module;
}
catch
{
if (Directory.Exists(str2))
{
Directory.Delete(str2, true);
}
throw;
}
finally
{
if ((module == null) && Directory.Exists(str2))
{
Directory.Delete(str2, true);
}
}
}
}
catch (Exception exception2)
{
ErrorRecord errorRecordForProcessingOfCimModule = RemoteDiscoveryHelper.GetErrorRecordForProcessingOfCimModule(exception2, remoteCimModule.ModuleName);
base.WriteError(errorRecordForProcessingOfCimModule);
info5 = null;
}
return info5;
}
