protected override void ProcessPackage(PackageProvider provider, IEnumerable <string> searchKey, SoftwareIdentity package)
{
base.ProcessPackage(provider, searchKey, package);
// return the object to the caller now.
WriteObject(package);
if (IncludeDependencies)
{
var missingDependencies = new HashSet <string>();
foreach (var dep in package.Dependencies)
{
// note: future work may be needed if the package sources currently selected by the user don't
// contain the dependencies.
var dependendcies = PackageManagementService.FindPackageByCanonicalId(dep, this);
var depPkg = dependendcies.OrderByDescending(pp => pp, SoftwareIdentityVersionComparer.Instance).FirstOrDefault();
if (depPkg == null)
{
missingDependencies.Add(dep);
Warning(Constants.Messages.UnableToFindDependencyPackage, dep);
}
else
{
ProcessPackage(depPkg.Provider, searchKey.Select(each => each + depPkg.Name).ToArray(), depPkg);
}
}
if (missingDependencies.Any())
{
Error(Constants.Errors.UnableToFindDependencyPackage, missingDependencies.JoinWithComma());
}
}
}
private bool InstallProviderFromInstaller(Package provider, Link link, string fastPath, BootstrapRequest request)
{
switch (link.MediaType)
{
case Iso19770_2.MediaType.MsiPackage:
case Iso19770_2.MediaType.MsuPackage:
return(InstallPackageFile(provider, fastPath, request));
case Iso19770_2.MediaType.PackageReference:
// let the core figure out how to install this package
var packages = PackageManagementService.FindPackageByCanonicalId(link.HRef.AbsoluteUri, request).ToArray();
switch (packages.Length)
{
case 0:
request.Warning("Unable to resolve package reference '{0}'", link.HRef);
return(false);
case 1:
return(InstallPackageReference(provider, fastPath, request, packages));
default:
request.Warning("Package Reference '{0}' resolves to {1} packages.", link.HRef, packages.Length);
return(false);
}
case Iso19770_2.MediaType.NuGetPackage:
return(InstallNugetPackage(provider, link, fastPath, request));
default:
request.Warning("Provider '{0}' with link '{1}' has unknown media type '{2}'.", provider.Name, link.HRef, link.MediaType);
return(false);
}
}
public void GetInstalledPackages(string name, string requiredVersion, string minimumVersion, string maximumVersion, BootstrapRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Debug("Calling '{0}::GetInstalledPackages' '{1}','{2}','{3}','{4}'", PackageProviderName, name, requiredVersion, minimumVersion, maximumVersion);
//search under the providerAssembies folder for the installed providers
var providers = PackageManagementService.AllProvidersFromProviderAssembliesLocation(request).Select(providerFileAssembly => {
//get the provider's name\version
var versionFolder = Path.GetDirectoryName(providerFileAssembly);
if (string.IsNullOrWhiteSpace(versionFolder))
{
return(null);
}
Version ver;
if (!Version.TryParse(Path.GetFileName(versionFolder), out ver))
{
//this will cover whether the providerFileAssembly is at top level as well as a bad version folder
//skip if the provider is at the top level as they are imported already via LoadProviders() during the initialization.
//the provider will be handled PackageManagementService.DynamicProviders below.
return(null);
}
var providerNameFolder = Path.GetDirectoryName(versionFolder);
if (!string.IsNullOrWhiteSpace(providerNameFolder))
{
var providerName = Path.GetFileName(providerNameFolder);
if (!string.IsNullOrWhiteSpace(providerName))
{
return(new {
Name = providerName,
Version = (FourPartVersion)ver,
ProviderPath = providerFileAssembly
});
}
}
return(null);
}).WhereNotNull();
// return all the dynamic package providers as packages
providers = providers.Concat(PackageManagementService.DynamicProviders.Select(each => new {
Name = each.ProviderName,
each.Version,
each.ProviderPath
})).Distinct();
var pp = request.LocalSource.Any() ? providers.Select(each => request.GetProviderFromFile(each.ProviderPath, false, true)).WhereNotNull() :
providers.Select(each => request.GetProvider(each.Name, each.Version)).WhereNotNull();
foreach (var p in pp)
{
request.YieldFromSwidtag(p, requiredVersion, minimumVersion, maximumVersion, name);
}
}
public void FindPackageTest()
{
using (CaptureConsole) {
var packages = Provider.FindPackage("zlib", null, null, null, new BasicHostImpl()).ToArray();
Assert.Equal(1, packages.Length);
var pkg1 = packages[0];
foreach (var pkg in packages)
{
Console.WriteLine("PKG (zlib?) : {0}", pkg.SwidTagText);
}
Assert.Equal(1, pkg1.Dependencies.Count());
Console.WriteLine("Getting Dependencies");
packages = PackageManagementService.FindPackageByCanonicalId(pkg1.Dependencies.FirstOrDefault(), new BasicHostImpl()).ToArray();
Assert.Equal(1, packages.Length);
Console.WriteLine("Processing Dependencies");
var pkg2 = packages[0];
foreach (var pkg in packages)
{
Console.WriteLine("PKG (zlib.redist?): {0}", pkg.SwidTagText);
}
}
}
private bool InstallPackageReference(Package provider, string fastPath, BootstrapRequest request, SoftwareIdentity[] packages)
{
IHostApi installRequest = request;
if (packages[0].Provider.Name.EqualsIgnoreCase("PowerShellGet") && !request.ProviderServices.IsElevated)
{
// if we're not elevated, we want powershellget to install to the user scope
installRequest = new object[] {
new {
GetOptionKeys = new Func <IEnumerable <string> >(() => request.OptionKeys.ConcatSingleItem("Scope")),
GetOptionValues = new Func <string, IEnumerable <string> >((key) => {
if (key != null && key.EqualsIgnoreCase("Scope"))
{
return("CurrentUser".SingleItemAsEnumerable());
}
return(request.GetOptionValues(key));
})
}
, installRequest
}.As <IHostApi>();
}
var installing = packages[0].Provider.InstallPackage(packages[0], installRequest);
SoftwareIdentity lastPackage = null;
foreach (var i in installing)
{
lastPackage = i;
// should we echo each package back as it comes back?
request.YieldSoftwareIdentity(i.FastPackageReference, i.Name, i.Version, i.VersionScheme, i.Summary, i.Source, i.SearchKey, i.FullPath, i.PackageFilename);
if (request.IsCanceled)
{
installing.Cancel();
}
}
if (!request.IsCanceled && lastPackage != null)
{
if (provider.Name.EqualsIgnoreCase("PowerShellGet"))
{
// special case. PSModules we can just ask the PowerShell provider to pick it up
// rather than try to scan for it.
PackageManagementService.TryLoadProviderViaMetaProvider("PowerShell", lastPackage.FullPath, request);
request.YieldFromSwidtag(provider, fastPath);
return(true);
}
// looks like it installed ok.
request.YieldFromSwidtag(provider, fastPath);
// rescan providers
PackageManagementService.LoadProviders(request.As <IRequest>());
return(true);
}
return(false);
}
public override bool ProcessRecordAsync()
{
if (Stopping)
{
return(false);
}
var packageProvider = PackageManagementService.SelectProviders(ProviderName, this).FirstOrDefault();
if (packageProvider == null)
{
Error(Errors.UnknownProvider, ProviderName);
return(false);
}
using (var sources = CancelWhenStopped(packageProvider.ResolvePackageSources(this))) {
// first, check if there is a source by this name already.
var existingSources = sources.Where(each => each.IsRegistered && each.Name.Equals(Name, StringComparison.OrdinalIgnoreCase)).ToArray();
if (existingSources.Any())
{
// if there is, and the user has said -Force, then let's remove it.
foreach (var existingSource in existingSources)
{
if (Force)
{
if (ShouldProcess(FormatMessageString(Constants.TargetPackageSource, existingSource.Name, existingSource.Location, existingSource.ProviderName), Constants.ActionReplacePackageSource).Result)
{
using (var removedSources = CancelWhenStopped(packageProvider.RemovePackageSource(existingSource.Name, this))) {
foreach (var removedSource in removedSources)
{
Verbose(Constants.OverwritingPackageSource, removedSource.Name);
}
}
}
}
else
{
Error(Errors.PackageSourceExists, existingSource.Name);
return(false);
}
}
}
}
if (ShouldProcess(FormatMessageString(Constants.TargetPackageSource, Name, Location, ProviderName), FormatMessageString(Constants.ActionRegisterPackageSource)).Result)
{
using (var added = CancelWhenStopped(packageProvider.AddPackageSource(Name, Location, Trusted, this))) {
foreach (var addedSource in added)
{
WriteObject(addedSource);
}
}
return(true);
}
return(false);
}
public IEnumerable <SoftwareIdentity> FindPackageByCanonicalId(string canonicalId, IRequest requestObject)
{
if (requestObject == null)
{
throw new ArgumentNullException("requestObject");
}
return(PackageManagementService.FindPackageByCanonicalId(canonicalId, requestObject));
}
private bool InstallAssemblyProvider(Package provider, Link link, string fastPath, BootstrapRequest request)
{
if (!Directory.Exists(request.DestinationPath))
{
request.Error(ErrorCategory.InvalidOperation, fastPath, Constants.Messages.DestinationPathNotSet);
return(false);
}
var targetFilename = link.Attributes[Iso19770_2.Discovery.TargetFilename];
if (string.IsNullOrWhiteSpace(targetFilename))
{
request.Error(ErrorCategory.InvalidOperation, fastPath, Constants.Messages.InvalidFilename);
return(false);
}
targetFilename = Path.GetFileName(targetFilename);
var targetFile = Path.Combine(request.DestinationPath, targetFilename);
// download the file
var file = request.DownloadAndValidateFile(provider.Name, provider._swidtag.Links.Where(each => each.Relationship == Iso19770_2.Relationship.InstallationMedia));
if (file != null)
{
// looks good! let's keep it
if (File.Exists(targetFile))
{
request.Debug("Removing old file '{0}'", targetFile);
targetFile.TryHardToDelete();
}
// is that file still there?
if (File.Exists(targetFile))
{
request.Error(ErrorCategory.InvalidOperation, fastPath, Constants.Messages.UnableToRemoveFile, targetFile);
return(false);
}
request.Debug("Copying file '{0}' to '{1}'", file, targetFile);
File.Copy(file, targetFile);
if (File.Exists(targetFile))
{
// since we only installed a single assembly, we can just ask to load that specific assembly.
if (PackageManagementService.TryToLoadProviderAssembly(targetFile, request))
{
// looks good to me.
request.YieldFromSwidtag(provider, fastPath);
return(true);
}
}
}
if (file != null)
{
file.TryHardToDelete();
}
return(false);
}
protected IEnumerable <PackageProvider> SelectProviders(string[] names)
{
if (names.IsNullOrEmpty())
{
return(PackageManagementService.SelectProviders(null, this).Where(each => !each.Features.ContainsKey(Constants.AutomationOnlyFeature)));
}
// you can manually ask for any provider by name, if it is for automation only.
return(names.SelectMany(each => PackageManagementService.SelectProviders(each, this))); // .Where(each => !each.Features.ContainsKey(Constants.AutomationOnlyFeature));
}
public override bool ProcessRecordAsync()
{
//Error out for the case where multiple provider names with any version specified
if (((!Name.IsNullOrEmpty() && Name.Length > 1) || Name[0].ContainsWildcards()) &&
((RequiredVersion != null) || (MinimumVersion != null) || (MaximumVersion != null)))
{
Error(Constants.Errors.MultipleNamesWithVersionNotAllowed);
return(false);
}
foreach (var path in Name)
{
var isRooted = false;
var resolvedPath = path;
if (!string.IsNullOrWhiteSpace(path))
{
if (IsRooted(path))
{
if ((RequiredVersion != null) || (MaximumVersion != null) || (MinimumVersion != null))
{
Error(Constants.Errors.FullProviderFilePathVersionNotAllowed);
}
try {
ProviderInfo provider = null;
Collection <string> resolvedPaths = GetResolvedProviderPathFromPSPath(path, out provider);
// Ensure the path is a single path from the file system provider
if ((resolvedPaths.Count > 1) ||
(!String.Equals(provider.Name, "FileSystem", StringComparison.OrdinalIgnoreCase)))
{
Error(Constants.Errors.FilePathMustBeFileSystemPath, path);
return(false);
}
resolvedPath = resolvedPaths[0];
isRooted = true;
} catch (Exception ex) {
Error(Constants.Errors.FileNotFound, ex.Message);
return(true);
}
}
foreach (var p in PackageManagementService.ImportPackageProvider(this, resolvedPath, RequiredVersion.ToVersion(),
MinimumVersion.ToVersion(), MaximumVersion.ToVersion(), isRooted, Force.IsPresent))
{
WriteObject(p);
}
}
} //foreach name
return(true);
}
protected IEnumerable <PackageProvider> SelectProviders(string name)
{
// you can manually ask for any provider by name, if it is for automation only.
var result = PackageManagementService.SelectProviders(name, this).ToArray(); //.Where(each => !each.Features.ContainsKey(Constants.AutomationOnlyFeature))
if (result.Length == 0)
{
Warning(Errors.UnknownProvider, name);
}
return(result);
}
protected IEnumerable <PackageProvider> SelectProviders(string[] names)
{
if (names.IsNullOrEmpty())
{
return(PackageManagementService.SelectProviders(null, SuppressErrorsAndWarnings).Where(each => !each.Features.ContainsKey(Microsoft.OneGet.Constants.Features.AutomationOnly)));
}
// you can manually ask for any provider by name, if it is for automation only.
if (IsInvocation)
{
return(names.SelectMany(each => PackageManagementService.SelectProviders(each, this)));
}
return(names.SelectMany(each => PackageManagementService.SelectProviders(each, SuppressErrorsAndWarnings)));
}
void CreatePackageManagementService(PackageManagementOptions options)
{
testProject = ProjectHelper.CreateTestProject();
fakePackageRepositoryFactory = new FakePackageRepositoryFactory();
fakePackageManagerFactory = new FakePackageManagerFactory();
fakeProjectService = new FakePackageManagementProjectService();
fakeOutputMessagesView = new FakePackageManagementOutputMessagesView();
fakeProjectService.CurrentProject = testProject;
packageManagementService =
new PackageManagementService(options,
fakePackageRepositoryFactory,
fakePackageManagerFactory,
fakeProjectService,
fakeOutputMessagesView);
installPackageHelper = new InstallPackageHelper(packageManagementService);
}
private bool ImportProvider(SoftwareIdentity[] list)
{
Verbose("Importing the package provider {0}", Name.JoinWithComma());
//after the provider gets installed, we are trying to load it
var providers = list.SelectMany(each => PackageManagementService.ImportPackageProvider(this.SuppressErrorsAndWarnings(IsProcessing), each.Name, each.Version.ToVersion(), null, null, false, true)).ToArray();
if (providers.Any())
{
Verbose(Resources.Messages.ProviderImported, providers.Select(e => e.ProviderPath).JoinWithComma());
return(true);
}
else
{
Warning(Resources.Messages.ProviderNameDifferentFromPackageName, Name.JoinWithComma());
}
return(false);
}
/// <summary>
/// Do a dfs visit. returns false if a cycle is encountered. Add the packageItem to the list at the end of each visit
/// </summary>
/// <param name="packageItem"></param>
/// <param name="dependencyToBeInstalled"></param>
/// <param name="permanentlyMarked"></param>
/// <param name="temporarilyMarked"></param>
/// <returns></returns>
internal bool DepthFirstVisit(SoftwareIdentity packageItem, HashSet <SoftwareIdentity> temporarilyMarked,
HashSet <SoftwareIdentity> permanentlyMarked, List <SoftwareIdentity> dependencyToBeInstalled)
{
// dependency loop detected because the element is temporarily marked
if (temporarilyMarked.Contains(packageItem))
{
return(false);
}
// this is permanently marked. So we don't have to visit it.
// This is to resolve a case where we have: A->B->C and A->C. Then we need this when we visit C again from either B or A.
if (permanentlyMarked.Contains(packageItem))
{
return(true);
}
// Mark this node temporarily so we can detect cycle.
temporarilyMarked.Add(packageItem);
// Visit the dependency
foreach (var dependency in packageItem.Dependencies)
{
var dependencies = PackageManagementService.FindPackageByCanonicalId(dependency, this);
var depPkg = dependencies.OrderByDescending(pp => pp, SoftwareIdentityVersionComparer.Instance).FirstOrDefault();
if (!DepthFirstVisit(depPkg, temporarilyMarked, permanentlyMarked, dependencyToBeInstalled))
{
// if dfs returns false then we have encountered a loop
return(false);
}
// otherwise visit the next dependency
}
// Add the package to the list so we can install later
dependencyToBeInstalled.Add(packageItem);
// Done with this node so mark it permanently
permanentlyMarked.Add(packageItem);
// Unmark it temporarily
temporarilyMarked.Remove(packageItem);
return(true);
}
protected override void ProcessPackage(PackageProvider provider, IEnumerable <string> searchKey, SoftwareIdentity package)
{
if (WhatIf)
{
// grab the dependencies and return them *first*
foreach (var dep in package.Dependencies)
{
// note: future work may be needed if the package sources currently selected by the user don't
// contain the dependencies.
var dependendcies = PackageManagementService.FindPackageByCanonicalId(dep, this);
foreach (var depPackage in dependendcies)
{
ProcessPackage(depPackage.Provider, searchKey.Select(each => each + depPackage.Name).ToArray(), depPackage);
}
}
}
base.ProcessPackage(provider, searchKey, package);
}
private bool InstallPackageFile(Package provider, string fastPath, BootstrapRequest request)
{
// we can download and verify this package and get the core to install it.
var file = request.DownloadAndValidateFile(provider._swidtag);
if (file != null)
{
// we have a valid file.
// run the installer
if (request.ProviderServices.Install(file, "", request))
{
// it installed ok!
request.YieldFromSwidtag(provider, fastPath);
PackageManagementService.LoadProviders(request.As <IRequest>());
return(true);
}
request.Warning(Constants.Messages.FailedProviderBootstrap, fastPath);
}
return(false);
}
public override bool ProcessRecordAsync()
{
if (Name.IsNullOrEmpty())
{
var providers = ListAvailable.IsPresent ? PackageManagementService.GetAvailableProviders(this, Name).ReEnumerable() : SelectProviders(Name).ReEnumerable();
var providerOrdered = providers.OrderBy(each => each.ProviderName);
// Get all available providers
foreach (var p in providerOrdered)
{
WriteObject(p);
}
}
else
{
ProcessProvidersFilteredByName();
}
return(true);
}
protected IEnumerable <PackageProvider> SelectProviders(string name)
{
// you can manually ask for any provider by name, if it is for automation only.
if (IsInvocation)
{
var result = PackageManagementService.SelectProviders(name, PackageManagementHost).ToArray();
if ((result.Length == 0) && ShouldLogError)
{
Error(Constants.Errors.UnknownProvider, name);
}
return(result);
}
var r = PackageManagementService.SelectProviders(name, PackageManagementHost.SuppressErrorsAndWarnings(IsProcessing)).ToArray();
if ((r.Length == 0) && ShouldLogError)
{
Error(Constants.Errors.UnknownProvider, name);
}
return(r);
}
private void ProcessProvidersFilteredByName()
{
//Do not log error when a provider is not found in the list returned by SelectProviders(). This allows the searching continues
//in the list of providers that are not loaded.
ShouldLogError = false;
var notfound = new List <string>();
foreach (var name in Name)
{
var providers = ListAvailable.IsPresent ? PackageManagementService.GetAvailableProviders(this, new[] { name }).ReEnumerable() : SelectProviders(name).ReEnumerable();
if (providers.Any())
{
var providerOrdered = providers.OrderByDescending(each => each.ProviderName);
foreach (var provider in providerOrdered)
{
WriteObject(provider);
}
}
else
{
notfound.Add(name);
}
}
//Error out if the specific provider is not found
if (notfound.Any())
{
if (notfound.Count == 1)
{
Error(ListAvailable.IsPresent ? Constants.Errors.UnknownProvider : Constants.Errors.UnknownProviderFromActivatedList, notfound.FirstOrDefault());
}
else
{
Error(ListAvailable.IsPresent ? Constants.Errors.UnknownProviders : Constants.Errors.UnknownProviderFromActivatedList, notfound.JoinWithComma());
}
}
notfound.Clear();
}
public override bool GenerateDynamicParameters()
{
var packageProvider = PackageManagementService.SelectProviders(ProviderName, this).FirstOrDefault();
if (packageProvider == null)
{
return(false);
}
// if the provider is selected, we can get package metadata keys from the provider
foreach (var md in packageProvider.GetDynamicOptions(OptionCategory.Source, this))
{
if (DynamicParameterDictionary.ContainsKey(md.Name))
{
// for now, we're just going to mark the existing parameter as also used by the second provider to specify it.
(DynamicParameterDictionary[md.Name] as CustomRuntimeDefinedParameter).Options.Add(md);
}
else
{
DynamicParameterDictionary.Add(md.Name, new CustomRuntimeDefinedParameter(md));
}
}
return(true);
}
protected override void ProcessPackage(PackageProvider provider, IEnumerable <string> searchKey, SoftwareIdentity package)
{
Debug("Calling ProcessPackage SearchKey = '{0}' and provider name ='{1}'", searchKey, package.ProviderName);
try {
base.ProcessPackage(provider, searchKey, package);
// output to console
WriteObject(AddPropertyToSoftwareIdentity(package));
if (IncludeDependencies)
{
var missingDependencies = new HashSet <string>();
foreach (var dep in package.Dependencies)
{
var dependendcies = PackageManagementService.FindPackageByCanonicalId(dep, this);
var depPkg = dependendcies.OrderByDescending(pp => pp, SoftwareIdentityVersionComparer.Instance).FirstOrDefault();
if (depPkg == null)
{
missingDependencies.Add(dep);
Warning(Constants.Messages.UnableToFindDependencyPackage, dep);
}
else
{
ProcessPackage(depPkg.Provider, searchKey.Select(each => each + depPkg.Name).ToArray(), depPkg);
}
}
if (missingDependencies.Any())
{
Error(Constants.Errors.UnableToFindDependencyPackage, missingDependencies.JoinWithComma());
}
}
} catch (Exception ex) {
Debug("Calling ProcessPackage {0}", ex.Message);
}
}
public void GetInstalledPackages(string name, string requiredVersion, string minimumVersion, string maximumVersion, BootstrapRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Debug("Calling '{0}::GetInstalledPackages' '{1}','{2}','{3}','{4}'", PackageProviderName, name, requiredVersion, minimumVersion, maximumVersion);
//search under the providerAssembies folder for the installed providers
var providers = PackageManagementService.AllProvidersFromProviderAssembliesLocation(request).Select(providerFileAssembly => {
//get the provider's name\version
var versionFolder = Path.GetDirectoryName(providerFileAssembly);
if (string.IsNullOrWhiteSpace(versionFolder))
{
return(null);
}
Version ver;
if (!Version.TryParse(Path.GetFileName(versionFolder), out ver))
{
//this will cover whether the providerFileAssembly is at top level as well as a bad version folder
//skip if the provider is at the top level as they are imported already via LoadProviders() during the initialization.
//the provider will be handled PackageManagementService.DynamicProviders below.
return(null);
}
var providerNameFolder = Path.GetDirectoryName(versionFolder);
if (!string.IsNullOrWhiteSpace(providerNameFolder))
{
var providerName = Path.GetFileName(providerNameFolder);
if (!string.IsNullOrWhiteSpace(providerName))
{
return(new {
Name = providerName,
Version = (FourPartVersion)ver,
ProviderPath = providerFileAssembly
});
}
}
return(null);
}).WhereNotNull();
// return all the dynamic package providers as packages
providers = providers.Concat(PackageManagementService.DynamicProviders.Select(each => new {
Name = each.ProviderName,
each.Version,
each.ProviderPath
})).Distinct();
foreach (var provider in providers)
{
// for each package manager, match it's name and version with the swidtag from the remote feed
var p = request.GetProvider(provider.Name, provider.Version);
if (p == null)
{
request.Debug("Dynamic provider '{0}' from '{1}' is not listed in a bootstrap feed.", provider.Name, provider.ProviderPath);
// we didn't find it. It's possible that the provider is listed elsewhere.
// well, we'll return as much info as we have.
continue;
}
request.YieldFromSwidtag(p, requiredVersion, minimumVersion, maximumVersion, name);
}
}
public IEnumerable <object> SelectProvidersWithFeature(string featureName, string value)
{
return(PackageManagementService.SelectProvidersWithFeature(featureName, value));
}
private bool InstallAssemblyProvider(Package provider, Link link, string fastPath, BootstrapRequest request, bool deleteFile = true)
{
request.Verbose(Resources.Messages.InstallingPackage, fastPath);
if (!Directory.Exists(request.DestinationPath(request)))
{
request.Error(ErrorCategory.InvalidOperation, fastPath, Constants.Messages.DestinationPathNotSet);
return(false);
}
string targetFilename = fastPath;
string file = fastPath;
//source can be from install-packageprovider or can be from the pipeline
if (!request.LocalSource.Any() && !fastPath.IsFile() && link != null)
{
targetFilename = link.Attributes[Iso19770_2.Discovery.TargetFilename];
// download the file
file = request.DownloadAndValidateFile(provider._swidtag);
}
if (string.IsNullOrWhiteSpace(targetFilename))
{
request.Error(ErrorCategory.InvalidOperation, fastPath, Constants.Messages.InvalidFilename);
return(false);
}
targetFilename = Path.GetFileName(targetFilename);
if (string.IsNullOrWhiteSpace(provider.Version))
{
request.Error(ErrorCategory.InvalidOperation, fastPath, Resources.Messages.MissingVersion);
return(false);
}
//the provider is installing to like this folder: \WindowsPowerShell\Modules\PackageManagement\ProviderAssemblies\nuget\2.8.5.127
//... providername\version\.dll
var versionFolder = Path.Combine(request.DestinationPath(request), provider.Name, provider.Version);
if (!Directory.Exists(versionFolder))
{
//we create it
Directory.CreateDirectory(versionFolder);
}
var targetFile = Path.Combine(versionFolder, targetFilename);
if (file != null)
{
try
{
// looks good! let's keep it
if (File.Exists(targetFile))
{
request.Debug("Removing old file '{0}'", targetFile);
targetFile.TryHardToDelete();
}
// is that file still there?
if (File.Exists(targetFile))
{
request.Error(ErrorCategory.InvalidOperation, fastPath, Constants.Messages.UnableToRemoveFile, targetFile);
return(false);
}
request.Debug("Copying file '{0}' to '{1}'", file, targetFile);
try {
File.Copy(file, targetFile);
}
catch (Exception ex) {
request.Debug(ex.StackTrace);
return(false);
}
if (File.Exists(targetFile))
{
request.Verbose(Resources.Messages.InstalledPackage, provider.Name, targetFile);
request.YieldFromSwidtag(provider, fastPath);
//Load the provider. This is needed when a provider has dependencies. For example, if Nuget provider has a dependent foobar
// provider and when 'Install-PackageProvider -name NuGet', we want both NuGet and Foobar provider gets loaded.
PackageManagementService.LoadProviderAssembly(request, targetFile, false);
return(true);
}
}
finally
{
if (deleteFile)
{
file.TryHardToDelete();
}
}
}
return(false);
}
public UpdatePackageHelper(PackageManagementService packageManagementService)
{
this.packageManagementService = packageManagementService;
}
public InstallPackageHelper(PackageManagementService packageManagementService)
{
this.packageManagementService = packageManagementService;
}
public object SelectProvider(string providerName)
{
return(PackageManagementService.SelectProviders(providerName, Extend()).FirstOrDefault(each => each.Name.EqualsIgnoreCase(providerName)));
}
public bool RequirePackageProvider(string packageProviderName, string minimumVersion)
{
var pp = (_provider as PowerShellPackageProvider);
return(PackageManagementService.RequirePackageProvider(pp == null ? Constants.ProviderNameUnknown : pp.GetPackageProviderName(), packageProviderName, minimumVersion, Extend()));
}
public IEnumerable <object> SelectProviders(string providerName)
{
return(PackageManagementService.SelectProviders(providerName, Extend()));
}
