// from reflector (system.management.automation)
//internal static T FromObjectAs<T>(object castObject)
//{
// T local = default(T);
// PSObject obj2 = castObject as PSObject;
// if (obj2 == null)
// {
// try
// {
// return (T)castObject;
// }
// catch (InvalidCastException)
// {
// return default(T);
// }
// }
// try
// {
// return (T)obj2.BaseObject;
// }
// catch (InvalidCastException)
// {
// return default(T);
// }
//}
private void WriteDebug(string message)
{
if (m_command != null)
{
m_command.WriteDebug(message);
}
}
public void Write(Verbosity verbosity, LogLevel level, string format, params object[] args)
{
switch (level)
{
case LogLevel.Error:
case LogLevel.Fatal:
_cmdlet.WriteWarning(string.Format(format, args));
return;
case LogLevel.Warning:
_cmdlet.WriteWarning(string.Format(format, args));
return;
case LogLevel.Information:
_cmdlet.WriteObject(string.Format(format, args));
return;
case LogLevel.Verbose:
_cmdlet.WriteVerbose(string.Format(format, args));
return;
case LogLevel.Debug:
_cmdlet.WriteDebug(string.Format(format, args));
return;
default:
throw new InvalidOperationException("Invalid log level.");
}
}
/// <summary>
/// Execute the given cmdlet in powershell with the given parameters after injecting the given exception. It is expected that the cmdlet has a runtime that can be used for receiving output
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmdlet">The cmdlet to execute</param>
/// <param name="name">The name of the cmdlet</param>
/// <param name="exception">The exception to inject into the error stream</param>
/// <param name="cmdletParameters">The parameters to pass to the cmdlet on the pipeline</param>
public static void ExecuteCmdletWithExceptionInPipeline <T>(this PSCmdlet cmdlet, string name, Exception exception, params KeyValuePair <string, object>[] cmdletParameters)
{
List <T> output = new List <T>();
using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create(RunspaceMode.NewRunspace))
{
var info = new CmdletInfo(name, cmdlet.GetType());
powershell.AddCommand("Write-Error");
powershell.AddParameter("Exception", exception);
powershell.Invoke();
powershell.Commands.Clear();
powershell.AddCommand(info);
foreach (var pair in cmdletParameters)
{
if (pair.Value == null)
{
powershell.AddParameter(pair.Key);
}
else
{
powershell.AddParameter(pair.Key, pair.Value);
}
}
Collection <T> result = powershell.Invoke <T>();
powershell.Streams.Error.ForEach(cmdlet.WriteError);
powershell.Streams.Debug.ForEach(d => cmdlet.WriteDebug(d.Message));
powershell.Streams.Verbose.ForEach(v => cmdlet.WriteWarning(v.Message));
powershell.Streams.Warning.ForEach(w => cmdlet.WriteWarning(w.Message));
if (result != null && result.Count > 0)
{
result.ForEach(r => cmdlet.WriteObject(r));
}
}
}
/// <summary>
/// Utility function used to create OrderByPropertyEntry for the supplied input object.
/// </summary>
/// <param name="cmdlet">PSCmdlet</param>
/// <param name="inputObject">Input Object.</param>
/// <param name="isCaseSensitive">Indicates if the Property value comparisons need to be case sensitive or not.</param>
/// <param name="cultureInfo">Culture Info that needs to be used for comparison.</param>
/// <returns>OrderByPropertyEntry for the supplied InputObject.</returns>
internal OrderByPropertyEntry CreateOrderByPropertyEntry(
PSCmdlet cmdlet,
PSObject inputObject,
bool isCaseSensitive,
CultureInfo cultureInfo)
{
Diagnostics.Assert(cmdlet != null, "cmdlet must be an instance");
if (_unExpandedParametersWithWildCardPattern != null)
{
ExpandExpressions(inputObject, _unExpandedParametersWithWildCardPattern, _mshParameterList);
}
List <ErrorRecord> evaluationErrors = new List <ErrorRecord>();
List <string> propertyNotFoundMsgs = new List <string>();
OrderByPropertyEntry result =
OrderByPropertyEntryEvaluationHelper.ProcessObject(inputObject, _mshParameterList, evaluationErrors, propertyNotFoundMsgs, isCaseSensitive, cultureInfo);
foreach (ErrorRecord err in evaluationErrors)
{
cmdlet.WriteError(err);
}
foreach (string debugMsg in propertyNotFoundMsgs)
{
cmdlet.WriteDebug(debugMsg);
}
return(result);
}
internal static List <OrderByPropertyEntry> CreateOrderMatrix(
PSCmdlet cmdlet,
List <PSObject> inputObjects,
List <MshParameter> mshParameterList
)
{
List <OrderByPropertyEntry> orderMatrixToCreate = new List <OrderByPropertyEntry>();
foreach (PSObject so in inputObjects)
{
if (so == null || so == AutomationNull.Value)
{
continue;
}
List <ErrorRecord> evaluationErrors = new List <ErrorRecord>();
List <string> propertyNotFoundMsgs = new List <string>();
OrderByPropertyEntry result =
OrderByPropertyEntryEvaluationHelper.ProcessObject(so, mshParameterList, evaluationErrors, propertyNotFoundMsgs);
foreach (ErrorRecord err in evaluationErrors)
{
cmdlet.WriteError(err);
}
foreach (string debugMsg in propertyNotFoundMsgs)
{
cmdlet.WriteDebug(debugMsg);
}
orderMatrixToCreate.Add(result);
}
return(orderMatrixToCreate);
}
internal static void DebugMessage(string message)
{
try
{
_cmdlet.WriteDebug(message);
}
catch
{
// Ignore
}
}
internal void OnTelemetrySent(PSCmdlet pscmdlet)
{
AzurePSQoSEvent qos;
if (_telemetry.TryGetValue(MetricHelper.TelemetryId, out qos))
{
qos.IsSuccess = (qos.Exception == null);
_telemetry.LogEvent(MetricHelper.TelemetryId);
_previousEndTime = DateTimeOffset.Now;
pscmdlet.WriteDebug(qos.ToString());
}
}
public static void Log <T>(T message, LogTarget logTarget, PSCmdlet invokeAll, bool noFileLogging = false)
{
string messageStr = null;
if (message is ErrorRecord)
{
//cast to object and then to ErrorRecord as direct casting is not allowed
messageStr = ((ErrorRecord)(object)message).Exception.Message;
}
else
{
messageStr = (string)(object)message;
}
string logEntry = string.Format("[{0}] {1}", System.DateTime.Now.ToString(datetimeFormat), messageStr);
switch (logTarget)
{
case LogTarget.File:
if (!noFileLogging)
{
using (StreamWriter streamWriter = new StreamWriter(logFile, append: true))
{
streamWriter.WriteLine(logEntry);
streamWriter.Close();
};
}
break;
case LogTarget.HostVerbose:
invokeAll.WriteVerbose(logEntry);
break;
case LogTarget.HostDebug:
invokeAll.WriteDebug(logEntry);
break;
case LogTarget.HostError:
if (message is ErrorRecord)
{
invokeAll.WriteError((ErrorRecord)(object)message);
}
break;
case LogTarget.HostWarning:
invokeAll.WriteWarning(logEntry);
break;
default:
break;
}
}
// Find all potential installation paths given a scope
public static List <string> GetAllInstallationPaths(PSCmdlet psCmdlet, ScopeType scope)
{
List <string> installationPaths = new List <string>();
var PSVersion6 = new Version(6, 0);
var isCorePS = psCmdlet.Host.Version >= PSVersion6;
string myDocumentsPath;
string programFilesPath;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
string powerShellType = isCorePS ? "PowerShell" : "WindowsPowerShell";
myDocumentsPath = Path.Combine(Environment.GetFolderPath(SpecialFolder.MyDocuments), powerShellType);
programFilesPath = Path.Combine(Environment.GetFolderPath(SpecialFolder.ProgramFiles), powerShellType);
}
else
{
// paths are the same for both Linux and MacOS
myDocumentsPath = System.IO.Path.Combine(Environment.GetFolderPath(SpecialFolder.LocalApplicationData), "Powershell");
programFilesPath = System.IO.Path.Combine("usr", "local", "share", "Powershell");
}
// The default user scope is CurrentUser
if (scope == ScopeType.AllUsers)
{
installationPaths.Add(System.IO.Path.Combine(programFilesPath, "Modules"));
installationPaths.Add(System.IO.Path.Combine(programFilesPath, "Scripts"));
}
else
{
installationPaths.Add(System.IO.Path.Combine(myDocumentsPath, "Modules"));
installationPaths.Add(System.IO.Path.Combine(myDocumentsPath, "Scripts"));
}
installationPaths = installationPaths.Distinct(StringComparer.InvariantCultureIgnoreCase).ToList();
installationPaths.ForEach(dir => psCmdlet.WriteDebug(string.Format("All paths to search: '{0}'", dir)));
return(installationPaths);
}
internal static List <OrderByPropertyEntry> CreateOrderMatrix(PSCmdlet cmdlet, List <PSObject> inputObjects, List <MshParameter> mshParameterList)
{
List <OrderByPropertyEntry> list = new List <OrderByPropertyEntry>();
foreach (PSObject obj2 in inputObjects)
{
if ((obj2 != null) && (obj2 != AutomationNull.Value))
{
List <ErrorRecord> errors = new List <ErrorRecord>();
List <string> propertyNotFoundMsgs = new List <string>();
OrderByPropertyEntry item = OrderByPropertyEntryEvaluationHelper.ProcessObject(obj2, mshParameterList, errors, propertyNotFoundMsgs);
foreach (ErrorRecord record in errors)
{
cmdlet.WriteError(record);
}
foreach (string str in propertyNotFoundMsgs)
{
cmdlet.WriteDebug(str);
}
list.Add(item);
}
}
return(list);
}
public List <PSObject> ProcessGetParams(string[] name, string version, bool prerelease, string path)
{
var dirsToSearch = new List <string>();
if (path != null)
{
cmdletPassedIn.WriteDebug(string.Format("Provided path is: '{0}'", path));
dirsToSearch.AddRange(Directory.GetDirectories(path).ToList());
}
else
{
// PSModules path
var psModulePath = Environment.GetEnvironmentVariable("PSModulePath");
var modulePaths = psModulePath.Split(';');
#if NET472
programFilesPath = System.IO.Path.Combine(Environment.GetFolderPath(SpecialFolder.ProgramFiles), "WindowsPowerShell");
myDocumentsPath = System.IO.Path.Combine(Environment.GetFolderPath(SpecialFolder.MyDocuments), "WindowsPowerShell");
#else
// If PS6+ on Windows
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
myDocumentsPath = System.IO.Path.Combine(Environment.GetFolderPath(SpecialFolder.MyDocuments), "PowerShell");
programFilesPath = System.IO.Path.Combine(Environment.GetFolderPath(SpecialFolder.ProgramFiles), "PowerShell");
}
else
{
// Paths are the same for both Linux and MacOS
myDocumentsPath = System.IO.Path.Combine(Environment.GetFolderPath(SpecialFolder.LocalApplicationData), "powershell");
programFilesPath = System.IO.Path.Combine("/usr", "local", "share", "powershell");
}
#endif
cmdletPassedIn.WriteDebug(string.Format("Current user scope path: '{0}'", myDocumentsPath));
cmdletPassedIn.WriteDebug(string.Format("All users scope path: '{0}'", programFilesPath));
/*** Will search first in PSModulePath, then will search in default paths ***/
foreach (var modulePath in modulePaths)
{
dirsToSearch.AddRange(Directory.GetDirectories(modulePath).ToList());
}
var pfModulesPath = System.IO.Path.Combine(programFilesPath, "Modules");
if (Directory.Exists(pfModulesPath))
{
dirsToSearch.AddRange(Directory.GetDirectories(pfModulesPath).ToList());
}
var mdModulesPath = System.IO.Path.Combine(myDocumentsPath, "Modules");
if (Directory.Exists(mdModulesPath))
{
dirsToSearch.AddRange(Directory.GetDirectories(mdModulesPath).ToList());
}
var pfScriptsPath = System.IO.Path.Combine(programFilesPath, "Scripts", "InstalledScriptInfos");
if (Directory.Exists(pfScriptsPath))
{
dirsToSearch.AddRange(Directory.GetFiles(pfScriptsPath).ToList());
}
var mdScriptsPath = System.IO.Path.Combine(myDocumentsPath, "Scripts", "InstalledScriptInfos");
if (Directory.Exists(mdScriptsPath))
{
dirsToSearch.AddRange(Directory.GetFiles(mdScriptsPath).ToList());
}
// uniqueify
dirsToSearch = dirsToSearch.Distinct().ToList();
}
foreach (var dir in dirsToSearch)
{
cmdletPassedIn.WriteDebug(string.Format("All directories to search: '{0}'", dir));
}
// Or a list of the passed in names
if (name != null && !name[0].Equals("*"))
{
var nameLowerCased = new List <string>();
var scriptXMLnames = new List <string>();
Array.ForEach(name, n => nameLowerCased.Add(n.ToLower()));
Array.ForEach(name, n => scriptXMLnames.Add((n + "_InstalledScriptInfo.xml").ToLower()));
dirsToSearch = dirsToSearch.FindAll(p => (nameLowerCased.Contains(new DirectoryInfo(p).Name.ToLower()) ||
scriptXMLnames.Contains((System.IO.Path.GetFileName(p)).ToLower())));
cmdletPassedIn.WriteDebug(dirsToSearch.Any().ToString());
}
// try to parse into a specific NuGet version
VersionRange versionRange = null;
if (version != null)
{
NuGetVersion specificVersion;
NuGetVersion.TryParse(version, out specificVersion);
if (specificVersion != null)
{
// exact version
versionRange = new VersionRange(specificVersion, true, specificVersion, true, null, null);
cmdletPassedIn.WriteDebug(string.Format("A specific version, '{0}', is specified", versionRange.ToString()));
}
else
{
// check if version range
versionRange = VersionRange.Parse(version);
cmdletPassedIn.WriteDebug(string.Format("A version range, '{0}', is specified", versionRange.ToString()));
}
}
List <string> installedPkgsToReturn = new List <string>();
IEnumerable <string> returnPkgs = null;
//2) use above list to check
// if the version specificed is a version range
if (versionRange != null)
{
foreach (var pkgPath in dirsToSearch)
{
cmdletPassedIn.WriteDebug(string.Format("Searching through package path: '{0}'", pkgPath));
var versionsDirs = Directory.GetDirectories(pkgPath);
foreach (var versionPath in versionsDirs)
{
cmdletPassedIn.WriteDebug(string.Format("Searching through package version path: '{0}'", versionPath));
NuGetVersion dirAsNugetVersion;
var dirInfo = new DirectoryInfo(versionPath);
NuGetVersion.TryParse(dirInfo.Name, out dirAsNugetVersion);
cmdletPassedIn.WriteDebug(string.Format("Directory parsed as NuGet version: '{0}'", dirAsNugetVersion));
if (versionRange.Satisfies(dirAsNugetVersion))
{
// just search scripts paths
if (pkgPath.ToLower().Contains("Scripts"))
{
if (File.Exists(pkgPath))
{
installedPkgsToReturn.Add(pkgPath);
}
}
else
{
// modules paths
versionsDirs = Directory.GetDirectories(pkgPath);
cmdletPassedIn.WriteDebug(string.Format("Getting sub directories from : '{0}'", pkgPath));
// Check if the pkg path actually has version sub directories.
if (versionsDirs.Length != 0)
{
Array.Sort(versionsDirs, StringComparer.OrdinalIgnoreCase);
Array.Reverse(versionsDirs);
var pkgXmlFilePath = System.IO.Path.Combine(versionsDirs.First(), "PSGetModuleInfo.xml");
// TODO: check if this xml file exists, if it doesn't check if it exists in a previous version
cmdletPassedIn.WriteDebug(string.Format("Found module XML: '{0}'", pkgXmlFilePath));
installedPkgsToReturn.Add(pkgXmlFilePath);
}
}
installedPkgsToReturn.Add(versionPath);
}
}
}
}
else
{
cmdletPassedIn.WriteDebug("No version provided-- check each path for the requested package");
// if no version is specified, just get the latest version
foreach (var pkgPath in dirsToSearch)
{
cmdletPassedIn.WriteDebug(string.Format("Searching through package path: '{0}'", pkgPath));
// just search scripts paths
if (pkgPath.ToLower().Contains("scripts"))
{
if (File.Exists(pkgPath)) //check to make sure properly formatted
{
installedPkgsToReturn.Add(pkgPath);
}
}
else
{
// modules paths
string[] versionsDirs = new string[0];
versionsDirs = Directory.GetDirectories(pkgPath);
// Check if the pkg path actually has version sub directories.
if (versionsDirs.Length != 0)
{
Array.Sort(versionsDirs, StringComparer.OrdinalIgnoreCase);
Array.Reverse(versionsDirs);
var pkgXmlFilePath = System.IO.Path.Combine(versionsDirs.First(), "PSGetModuleInfo.xml");
// TODO: check if this xml file exists, if it doesn't check if it exists in a previous version
cmdletPassedIn.WriteDebug(string.Format("Found package XML: '{0}'", pkgXmlFilePath));
installedPkgsToReturn.Add(pkgXmlFilePath);
}
}
}
}
// Flatten returned pkgs before displaying output returnedPkgsFound.Flatten().ToList()[0]
var flattenedPkgs = installedPkgsToReturn.Flatten();
List <PSObject> foundInstalledPkgs = new List <PSObject>();
foreach (string xmlFilePath in flattenedPkgs)
{
cmdletPassedIn.WriteDebug(string.Format("Reading package metadata from: '{0}'", xmlFilePath));
// Open xml and read metadata from it
if (File.Exists(xmlFilePath))
{
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> nameInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> versionInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> typeInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> descriptionInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> authorInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> companyNameInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> copyrightInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> publishedDateInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> installedDateInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> updatedDateInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> licenseUriInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> projectUriInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> iconUriInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> tagsInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> includesInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> powerShellGetFormatVersionInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> releaseNotesInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> dependenciesInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> repositorySourceLocationInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> repositoryInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> additionalMetadataInfo;
ReadOnlyPSMemberInfoCollection <PSPropertyInfo> installedLocationInfo;
//var isPrelease = false;
using (StreamReader sr = new StreamReader(xmlFilePath))
{
string text = sr.ReadToEnd();
var deserializedObj = (PSObject)PSSerializer.Deserialize(text);
nameInfo = deserializedObj.Properties.Match("Name");
versionInfo = deserializedObj.Properties.Match("Version");
typeInfo = deserializedObj.Properties.Match("Type");
descriptionInfo = deserializedObj.Properties.Match("Description");
authorInfo = deserializedObj.Properties.Match("Author");
companyNameInfo = deserializedObj.Properties.Match("CompanyName");
copyrightInfo = deserializedObj.Properties.Match("Copyright");
publishedDateInfo = deserializedObj.Properties.Match("PublishedDate");
installedDateInfo = deserializedObj.Properties.Match("InstalledDate");
updatedDateInfo = deserializedObj.Properties.Match("UpdatedDate");
licenseUriInfo = deserializedObj.Properties.Match("LicenseUri");
projectUriInfo = deserializedObj.Properties.Match("ProjectUri");
iconUriInfo = deserializedObj.Properties.Match("IconUri");
tagsInfo = deserializedObj.Properties.Match("Tags");
includesInfo = deserializedObj.Properties.Match("Includes");
powerShellGetFormatVersionInfo = deserializedObj.Properties.Match("PowerShellGetFormatVersion");
releaseNotesInfo = deserializedObj.Properties.Match("ReleaseNotes");
dependenciesInfo = deserializedObj.Properties.Match("Dependencies");
repositorySourceLocationInfo = deserializedObj.Properties.Match("RepositorySourceLocation");
repositoryInfo = deserializedObj.Properties.Match("Repository");
additionalMetadataInfo = deserializedObj.Properties.Match("AdditionalMetadata");
installedLocationInfo = deserializedObj.Properties.Match("InstalledLocation");
/* // testing adding prerelease parameter
* additionalMetadataInfo = deserializedObj.Properties.Match("AdditionalMetadata");
* if (additionalMetadataInfo.Any())
* {
* isPrelease = additionalMetadataInfo.FirstOrDefault().Value.ToString().Contains("IsPrerelease=true");
* if ((isPrelease == true) && _prerelease) // find a stable version of the pkg {}
* }
*/
};
// if -Prerelease is not passed in as a parameter, don't allow prerelease pkgs to be returned,
// we still want all pkgs to be returned if -Prerelease is passed in as a param
//if ((_prerelease == false && isPrelease == false) || _prerelease == true)
//{
//var foundPkgs = List<PSObject>();
PSObject pkgAsPSObject = new PSObject();
try
{
pkgAsPSObject.Members.Add(new PSNoteProperty("Name", nameInfo.Any()? nameInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("Version", versionInfo.Any()? versionInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("Type", typeInfo.Any()? typeInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("Description", descriptionInfo.Any()? descriptionInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("Author", authorInfo.Any()? authorInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("CompanyName", companyNameInfo.Any()? companyNameInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("Copyright", copyrightInfo.Any()? copyrightInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("PublishedDate", publishedDateInfo.Any()? publishedDateInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("InstalledDate", installedDateInfo.Any()? installedDateInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("UpdatedDate", updatedDateInfo.Any()? updatedDateInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("LicenseUri", licenseUriInfo.Any()? licenseUriInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("ProjectUri", projectUriInfo.Any()? projectUriInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("IconUri", iconUriInfo.Any()? iconUriInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("Tags", tagsInfo.Any()? tagsInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("Includes", includesInfo.Any()? includesInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("PowerShellGetFormatVersion", powerShellGetFormatVersionInfo.Any()? powerShellGetFormatVersionInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("ReleaseNotes", releaseNotesInfo.Any()? releaseNotesInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("Dependencies", dependenciesInfo.Any()? dependenciesInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("RepositorySourceLocation", repositorySourceLocationInfo.Any()? repositorySourceLocationInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("Repository", repositoryInfo.Any()? repositoryInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("AdditionalMetadata", additionalMetadataInfo.Any()? additionalMetadataInfo.FirstOrDefault().Value : string.Empty));
pkgAsPSObject.Members.Add(new PSNoteProperty("InstalledLocation", installedLocationInfo.Any()? installedLocationInfo.FirstOrDefault().Value : string.Empty));
// verify that this works, then add the object to a list and return it
//WriteObject(pkgAsPSObject);
foundInstalledPkgs.Add(pkgAsPSObject);
}
catch { }
}
}
// return here
return(foundInstalledPkgs);
}
private void LogDebug(string format, params object[] parameters)
{
var message = String.Format(format, parameters);
cmdlet.WriteDebug(message);
}
internal static void DebugMessage(string message)
{
_cmdlet.WriteDebug(message);
}
public void InstallPackages(
string[] names,
VersionRange versionRange,
bool prerelease,
string[] repository,
bool acceptLicense,
bool quiet,
bool reinstall,
bool force,
bool trustRepository,
bool noClobber,
PSCredential credential,
string requiredResourceFile,
string requiredResourceJson,
Hashtable requiredResourceHash,
string specifiedPath,
bool asNupkg,
bool includeXML,
List <string> pathsToInstallPkg)
{
_cmdletPassedIn.WriteDebug(string.Format("Parameters passed in >>> Name: '{0}'; Version: '{1}'; Prerelease: '{2}'; Repository: '{3}'; " +
"AcceptLicense: '{4}'; Quiet: '{5}'; Reinstall: '{6}'; TrustRepository: '{7}'; NoClobber: '{8}';",
string.Join(",", names),
(_versionRange != null ? _versionRange.OriginalString : string.Empty),
prerelease.ToString(),
repository != null ? string.Join(",", repository) : string.Empty,
acceptLicense.ToString(),
quiet.ToString(),
reinstall.ToString(),
trustRepository.ToString(),
noClobber.ToString()));
_versionRange = versionRange;
_prerelease = prerelease;
_acceptLicense = acceptLicense;
_quiet = quiet;
_reinstall = reinstall;
_force = force;
_trustRepository = trustRepository;
_noClobber = noClobber;
_credential = credential;
_specifiedPath = specifiedPath;
_asNupkg = asNupkg;
_includeXML = includeXML;
_pathsToInstallPkg = pathsToInstallPkg;
// Go through the repositories and see which is the first repository to have the pkg version available
ProcessRepositories(names, repository, _trustRepository, _credential);
}
public Dictionary <string, List <string> > CheckRuleExtension(string[] path, PSCmdlet cmdlet)
{
Dictionary <string, List <string> > results = new Dictionary <string, List <string> >();
List <string> invalidPaths = new List <string>();
List <string> validDllPaths = new List <string>();
List <string> validModPaths = new List <string>();
// Gets valid module names
foreach (string childPath in path)
{
try
{
cmdlet.WriteVerbose(string.Format(CultureInfo.CurrentCulture, Strings.CheckModuleName, childPath));
string resolvedPath = string.Empty;
// Users may provide a valid module path or name,
// We have to identify the childPath is really a directory or just a module name.
// You can also consider following two commands.
// Get-ScriptAnalyzerRule -RuleExtension "ContosoAnalyzerRules"
// Get-ScriptAnalyzerRule -RuleExtension "%USERPROFILE%\WindowsPowerShell\Modules\ContosoAnalyzerRules"
if (Path.GetDirectoryName(childPath) == string.Empty)
{
resolvedPath = childPath;
}
else
{
resolvedPath = cmdlet.SessionState.Path
.GetResolvedPSPathFromPSPath(childPath).First().ToString();
}
using (System.Management.Automation.PowerShell posh =
System.Management.Automation.PowerShell.Create())
{
string script = string.Format(CultureInfo.CurrentCulture, "Get-Module -Name '{0}' -ListAvailable", resolvedPath);
PSModuleInfo moduleInfo = posh.AddScript(script).Invoke <PSModuleInfo>().First();
// Adds original path, otherwise path.Except<string>(validModPaths) will fail.
// It's possible that user can provide something like this:
// "..\..\..\ScriptAnalyzer.UnitTest\modules\CommunityAnalyzerRules\CommunityAnalyzerRules.psd1"
if (moduleInfo.ExportedFunctions.Count > 0)
{
validModPaths.Add(childPath);
}
}
}
catch
{
// User may provide an invalid module name, like c:\temp.
// It's a invalid name for a Windows PowerShell module,
// But we need test it further since we allow user to provide a folder to extend rules.
// You can also consider following two commands.
// Get-ScriptAnalyzerRule -RuleExtension "ContosoAnalyzerRules", "C:\Temp\ExtendScriptAnalyzerRules.dll"
// Get-ScriptAnalyzerRule -RuleExtension "ContosoAnalyzerRules", "C:\Temp\"
continue;
}
}
// Gets valid dll paths
foreach (string childPath in path.Except <string>(validModPaths))
{
try
{
string resolvedPath = cmdlet.SessionState.Path
.GetResolvedPSPathFromPSPath(childPath).First().ToString();
cmdlet.WriteDebug(string.Format(CultureInfo.CurrentCulture, Strings.CheckAssemblyFile, resolvedPath));
if (String.Equals(Path.GetExtension(resolvedPath), ".dll", StringComparison.OrdinalIgnoreCase))
{
if (!File.Exists(resolvedPath))
{
invalidPaths.Add(resolvedPath);
continue;
}
}
else
{
if (!Directory.Exists(resolvedPath))
{
invalidPaths.Add(resolvedPath);
continue;
}
}
validDllPaths.Add(resolvedPath);
}
catch
{
invalidPaths.Add(childPath);
}
}
// Resloves relative paths.
try
{
for (int i = 0; i < validModPaths.Count; i++)
{
validModPaths[i] = cmdlet.SessionState.Path
.GetResolvedPSPathFromPSPath(validModPaths[i]).First().ToString();
}
for (int i = 0; i < validDllPaths.Count; i++)
{
validDllPaths[i] = cmdlet.SessionState.Path
.GetResolvedPSPathFromPSPath(validDllPaths[i]).First().ToString();
}
}
catch
{
// If GetResolvedPSPathFromPSPath failed. We can safely ignore the exception.
// Because GetResolvedPSPathFromPSPath always fails when trying to resolve a module name.
}
// Returns valid rule extensions
results.Add("InvalidPaths", invalidPaths);
results.Add("ValidModPaths", validModPaths);
results.Add("ValidDllPaths", validDllPaths);
return(results);
}
public void WriteDebug(string text)
{
_cmd?.WriteDebug(text);
}
public static List <string> GetAllResourcePaths(PSCmdlet psCmdlet)
{
string psModulePath = Environment.GetEnvironmentVariable("PSModulePath");
List <string> resourcePaths = psModulePath.Split(';').ToList();
List <string> pathsToSearch = new List <string>();
var PSVersion6 = new Version(6, 0);
var isCorePS = psCmdlet.Host.Version >= PSVersion6;
string myDocumentsPath;
string programFilesPath;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
string powerShellType = isCorePS ? "PowerShell" : "WindowsPowerShell";
myDocumentsPath = Path.Combine(Environment.GetFolderPath(SpecialFolder.MyDocuments), powerShellType);
programFilesPath = Path.Combine(Environment.GetFolderPath(SpecialFolder.ProgramFiles), powerShellType);
}
else
{
// paths are the same for both Linux and MacOS
myDocumentsPath = System.IO.Path.Combine(Environment.GetFolderPath(SpecialFolder.LocalApplicationData), "Powershell");
programFilesPath = System.IO.Path.Combine("usr", "local", "share", "Powershell");
}
// will search first in PSModulePath, then will search in default paths
resourcePaths.Add(System.IO.Path.Combine(myDocumentsPath, "Modules"));
resourcePaths.Add(System.IO.Path.Combine(programFilesPath, "Modules"));
resourcePaths.Add(System.IO.Path.Combine(myDocumentsPath, "Scripts"));
resourcePaths.Add(System.IO.Path.Combine(programFilesPath, "Scripts"));
// resourcePaths should now contain, eg:
// ./PowerShell/Scripts
// ./PowerShell/Modules
// add all module directories or script files
foreach (string path in resourcePaths)
{
psCmdlet.WriteDebug(string.Format("Retrieving directories in the path '{0}'", path));
if (path.EndsWith("Scripts"))
{
try
{
pathsToSearch.AddRange(GetDirectoryFiles(path));
}
catch (Exception e)
{
psCmdlet.WriteVerbose(string.Format("Error retrieving files from '{0}': '{1}'", path, e.Message));
}
}
else
{
try
{
pathsToSearch.AddRange(GetSubDirectories(path));
}
catch (Exception e)
{
psCmdlet.WriteVerbose(string.Format("Error retrieving directories from '{0}': '{1}'", path, e.Message));
}
}
}
// resourcePaths should now contain eg:
// ./PowerShell/Scripts/Test-Script.ps1
// ./PowerShell/Modules/TestModule
// need to use .ToList() to cast the IEnumerable<string> to type List<string>
pathsToSearch = pathsToSearch.Distinct(StringComparer.InvariantCultureIgnoreCase).ToList();
pathsToSearch.ForEach(dir => psCmdlet.WriteDebug(string.Format("All paths to search: '{0}'", dir)));
return(pathsToSearch);
}
public IEnumerable <PSResourceInfo> FindByResourceName(
string[] name,
ResourceType type,
string version,
SwitchParameter prerelease,
string[] tag,
string[] repository,
PSCredential credential,
SwitchParameter includeDependencies)
{
_type = type;
_version = version;
_prerelease = prerelease;
_tag = tag;
_credential = credential;
_includeDependencies = includeDependencies;
Dbg.Assert(name.Length != 0, "Name length cannot be 0");
_pkgsLeftToFind = name.ToList();
List <PSRepositoryInfo> repositoriesToSearch;
try
{
repositoriesToSearch = RepositorySettings.Read(repository, out string[] errorList);
foreach (string error in errorList)
{
_cmdletPassedIn.WriteError(new ErrorRecord(
new PSInvalidOperationException(error),
"ErrorGettingSpecifiedRepo",
ErrorCategory.InvalidOperation,
this));
}
}
catch (Exception e)
{
_cmdletPassedIn.ThrowTerminatingError(new ErrorRecord(
new PSInvalidOperationException(e.Message),
"ErrorLoadingRepositoryStoreFile",
ErrorCategory.InvalidArgument,
this));
yield break;
}
// loop through repositoriesToSearch and if PSGallery add it to list with same priority as PSGallery repo
for (int i = 0; i < repositoriesToSearch.Count; i++)
{
if (String.Equals(repositoriesToSearch[i].Name, _psGalleryRepoName, StringComparison.InvariantCultureIgnoreCase))
{
// for PowerShellGallery, Module and Script resources have different endpoints so separate repositories have to be registered
// with those endpoints in order for the NuGet APIs to search across both in the case where name includes '*'
// detect if Script repository needs to be added and/or Module repository needs to be skipped
Uri psGalleryScriptsUrl = new Uri("http://www.powershellgallery.com/api/v2/items/psscript/");
PSRepositoryInfo psGalleryScripts = new PSRepositoryInfo(_psGalleryScriptsRepoName, psGalleryScriptsUrl, repositoriesToSearch[i].Priority, false);
if (_type == ResourceType.None)
{
_cmdletPassedIn.WriteDebug("Null Type provided, so add PSGalleryScripts repository");
repositoriesToSearch.Insert(i + 1, psGalleryScripts);
}
else if (_type != ResourceType.None && _type == ResourceType.Script)
{
_cmdletPassedIn.WriteDebug("Type Script provided, so add PSGalleryScripts and remove PSGallery (Modules only)");
repositoriesToSearch.Insert(i + 1, psGalleryScripts);
repositoriesToSearch.RemoveAt(i); // remove PSGallery
}
}
}
for (int i = 0; i < repositoriesToSearch.Count && _pkgsLeftToFind.Any(); i++)
{
_cmdletPassedIn.WriteDebug(string.Format("Searching in repository {0}", repositoriesToSearch[i].Name));
foreach (var pkg in SearchFromRepository(
repositoryName: repositoriesToSearch[i].Name,
repositoryUrl: repositoriesToSearch[i].Url))
{
yield return(pkg);
}
}
}
// Filter by user provided version
public IEnumerable <String> FilterPkgPathsByVersion(VersionRange versionRange, List <string> dirsToSearch)
{
Dbg.Assert(versionRange != null, "Version Range cannot be null");
// if no version is specified, just get the latest version
foreach (string pkgPath in dirsToSearch)
{
_cmdletPassedIn.WriteDebug(string.Format("Searching through package path: '{0}'", pkgPath));
// if this is a module directory
if (Directory.Exists(pkgPath))
{
// search modules paths
// ./Modules/Test-Module/1.0.0
// ./Modules/Test-Module/2.0.0
_cmdletPassedIn.WriteDebug(string.Format("Searching through package path: '{0}'", pkgPath));
string[] versionsDirs = Utils.GetSubDirectories(pkgPath);
if (versionsDirs.Length == 0)
{
_cmdletPassedIn.WriteVerbose(
$"No version subdirectories found for path: {pkgPath}");
continue;
}
// sort and reverse to get package versions in descending order to maintain consistency with V2
Array.Sort(versionsDirs);
Array.Reverse(versionsDirs);
foreach (string versionPath in versionsDirs)
{
_cmdletPassedIn.WriteDebug(string.Format("Searching through package version path: '{0}'", versionPath));
DirectoryInfo dirInfo = new DirectoryInfo(versionPath);
// if the version is not valid, we'll just skip it and output a debug message
if (!NuGetVersion.TryParse(dirInfo.Name, out NuGetVersion dirAsNugetVersion))
{
_cmdletPassedIn.WriteVerbose(string.Format("Leaf directory in path '{0}' cannot be parsed into a version.", versionPath));
// skip to next iteration of the loop
continue;
}
_cmdletPassedIn.WriteVerbose(string.Format("Directory parsed as NuGet version: '{0}'", dirAsNugetVersion));
if (versionRange.Satisfies(dirAsNugetVersion))
{
// This will be one version or a version range.
// yield results then continue with this iteration of the loop
yield return(versionPath);
}
}
}
else if (File.Exists(pkgPath))
{
// if it's a script
if (versionRange == null || versionRange == VersionRange.All)
{
// yield results then continue with this iteration of the loop
yield return(pkgPath);
// We are now done with the current iteration of the for loop because
// only one script version can be installed in a particular script path at a time.
// if looking for all versions and one was found, then we have found all possible versions at that ./Scripts path
// and do not need to parse and check for the version number in the metadata file.
}
else
{
// check to make sure it's within the version range.
// script versions will be parsed from the script xml file
PSResourceInfo scriptInfo = OutputPackageObject(pkgPath, _scriptDictionary);
if (scriptInfo == null)
{
// if script was not found skip to the next iteration of the loop
continue;
}
if (!NuGetVersion.TryParse(scriptInfo.Version.ToString(), out NuGetVersion scriptVersion))
{
_cmdletPassedIn.WriteVerbose(string.Format("Version '{0}' could not be properly parsed from the script metadata file from the script installed at '{1}'", scriptInfo.Version.ToString(), scriptInfo.InstalledLocation));
}
else if (versionRange.Satisfies(scriptVersion))
{
_scriptDictionary.Add(pkgPath, scriptInfo);
yield return(pkgPath);
}
}
}
}
}
