/// <summary>
/// Resolves and returns Package Sources to the client.
///
/// Specified sources are passed in via the request object (<c>request.GetSources()</c>).
///
/// Sources are returned using <c>request.YieldPackageSource(...)</c>
/// </summary>
/// <param name="request">An object passed in from the PackageManagement that contains functions that can be used to interact with its Provider</param>
public void ResolvePackageSources(NuGetRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Debug(Resources.Messages.DebugInfoCallMethod, PackageProviderName, "ResolvePackageSources");
var selectedSources = request.SelectedSources;
try
{
foreach (var source in selectedSources)
{
request.Debug(Resources.Messages.YieldingPackageSource, PackageProviderName, source);
request.YieldPackageSource(source.Name, source.Location, source.Trusted, source.IsRegistered, source.IsValidated);
}
}
catch (Exception e)
{
e.Dump(request);
}
request.Debug(Resources.Messages.DebugInfoReturnCall, PackageProviderName, "ResolvePackageSources");
}
private bool InstallSinglePackage(PackageItem pkgItem, NuGetRequest request, ProgressTracker progressTracker)
{
bool packageWasInstalled = false;
PackageItem packageToBeInstalled;
request.Debug(Messages.DebugInfoCallMethod, "NuGetFilesFeed3", "InstallSinglePackage");
try
{
if (pkgItem == null || pkgItem.PackageSource == null || pkgItem.PackageSource.Repository == null)
{
return(false);
}
// If the source location exists as a directory then we try to get the file location and provide to the packagelocal
if (Directory.Exists(pkgItem.PackageSource.Location))
{
var fileLocation = pkgItem.PackageSource.Repository.FindPackage(new NuGetSearchContext()
{
PackageInfo = new PackageEntryInfo(pkgItem.Id),
RequiredVersion = new Provider.Utility.SemanticVersion(pkgItem.Version)
}, request).FullFilePath;
packageToBeInstalled = NuGetClient.InstallPackageLocal(pkgItem.Id, pkgItem.Version, request, pkgItem.PackageSource, fileLocation, progressTracker);
}
else
{
string httpquery = MakeDownloadUri(pkgItem);
// wait for the result from installpackage
packageToBeInstalled = NuGetClient.InstallPackage(pkgItem.Id, pkgItem.Version, request, pkgItem.PackageSource,
httpquery, pkgItem.Package.PackageHash, pkgItem.Package.PackageHashAlgorithm, progressTracker);
}
// Package is installed successfully
if (packageToBeInstalled != null)
{
// if this is a http repository, return metadata from online
if (!pkgItem.PackageSource.Repository.IsFile)
{
request.YieldPackage(pkgItem, packageToBeInstalled.PackageSource.Name, packageToBeInstalled.FullPath);
}
else
{
request.YieldPackage(packageToBeInstalled, packageToBeInstalled.PackageSource.Name, packageToBeInstalled.FullPath);
}
packageWasInstalled = true;
}
return(packageWasInstalled);
}
finally
{
request.Debug(Messages.DebugInfoReturnCall, "NuGetFilesFeed3", "InstallSinglePackage");
}
}
/// <summary>
/// </summary>
/// <param name="name"></param>
/// <param name="requiredVersion"></param>
/// <param name="minimumVersion"></param>
/// <param name="maximumVersion"></param>
/// <param name="id"></param>
/// <param name="request"></param>
/// <returns></returns>
public void FindPackage(string name, string requiredVersion, string minimumVersion, string maximumVersion, int id, NuGetRequest request)
{
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::FindPackage' '{1}','{2}','{3}','{4}','{5}'", PackageProviderName, name, requiredVersion, minimumVersion, maximumVersion, id);
requiredVersion = requiredVersion.FixVersion();
if (!string.IsNullOrEmpty(requiredVersion))
{
if (request.FindByCanonicalId && requiredVersion.IndexOfAny("()[],".ToCharArray()) == -1)
{
// when resolving packages via a canonical id, treat a lone version (ie 1.0 -> 1.0 <= x) string as a nuget version range:
minimumVersion = requiredVersion;
maximumVersion = null;
requiredVersion = null;
}
else
{
minimumVersion = null;
maximumVersion = null;
}
}
else
{
minimumVersion = minimumVersion.FixVersion();
maximumVersion = maximumVersion.FixVersion();
}
if (!IsValidVersionRange(minimumVersion, maximumVersion))
{
request.Error(ErrorCategory.InvalidArgument, minimumVersion + maximumVersion, Constants.Messages.InvalidVersionRange, minimumVersion, maximumVersion);
return;
}
// get the package by ID first.
// if there are any packages, yield and return
if (!string.IsNullOrWhiteSpace(name))
{
if (request.YieldPackages(request.GetPackageById(name, requiredVersion, minimumVersion, maximumVersion), name) || request.FoundPackageById)
{
// if we actaully found some by that id, but didn't make it past the filter, we're done.
return;
}
}
// have we been cancelled?
if (request.IsCanceled)
{
return;
}
// Try searching for matches and returning those.
request.YieldPackages(request.SearchForPackages(name, requiredVersion, minimumVersion, maximumVersion), name);
request.Debug("Finished '{0}::FindPackage' '{1}','{2}','{3}','{4}','{5}'", PackageProviderName, name, requiredVersion, minimumVersion, maximumVersion, id);
}
/// <summary>
/// Installs a given package.
/// </summary>
/// <param name="fastPackageReference">A provider supplied identifier that specifies an exact package</param>
/// <param name="request">An object passed in from the PackageManagement that contains functions that can be used to interact with its Provider</param>
public void InstallPackage(string fastPackageReference, NuGetRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Debug(Resources.Messages.DebugInfoCallMethod3, PackageProviderName, "InstallPackage", fastPackageReference);
// Enforce use of TLS 1.2 when sending request
var securityProtocol = System.Net.ServicePointManager.SecurityProtocol;
System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12;
try {
var pkgItem = request.GetPackageByFastpath(fastPackageReference);
if (pkgItem == null)
{
request.WriteError(ErrorCategory.InvalidArgument, fastPackageReference, Constants.Messages.UnableToResolvePackage);
return;
}
if ((pkgItem.PackageSource == null) || (pkgItem.PackageSource.Location == null) || (pkgItem.Package == null))
{
request.Debug(Resources.Messages.VariableCheck, "PackageSource or PackageSource.Location or Package object", "null");
request.WriteError(ErrorCategory.ObjectNotFound, fastPackageReference, Constants.Messages.UnableToResolvePackage, pkgItem.Id);
return;
}
request.Debug(Resources.Messages.VariableCheck, "Package version", pkgItem.Version);
request.Debug(Resources.Messages.VariableCheck, "Request's Destination", request.Destination);
// got this far, let's install the package we came here for.
if (!pkgItem.PackageSource.Repository.InstallPackage(new PublicObjectView(pkgItem), request))
{
// package itself didn't install. Write error
request.WriteError(ErrorCategory.InvalidResult, pkgItem.Id, Constants.Messages.PackageFailedInstallOrDownload, pkgItem.Id, CultureInfo.CurrentCulture.TextInfo.ToLower(Constants.Install));
return;
}
} catch (Exception ex) {
ex.Dump(request);
request.WriteError(ErrorCategory.InvalidOperation, fastPackageReference, ex.Message);
} finally {
// Change back to user specified security protocol
System.Net.ServicePointManager.SecurityProtocol = securityProtocol;
}
}
private IEnumerable <IPackage> SearchImpl(string searchTerm, NuGetRequest nugetRequest)
{
if (nugetRequest == null)
{
yield break;
}
nugetRequest.Debug(Resources.Messages.SearchingRepository, "LocalPackageRepository", Source);
var files = Directory.GetFiles(Source);
foreach (var package in nugetRequest.FilterOnTags(files.Select(nugetRequest.GetPackageByFilePath).Where(pkgItem => pkgItem != null).Select(pkg => pkg.Package)))
{
yield return(package);
}
// look in the package source location for directories that contain nupkg files.
var subdirs = Directory.EnumerateDirectories(Source, "*", SearchOption.AllDirectories);
foreach (var subdir in subdirs)
{
var nupkgs = Directory.EnumerateFileSystemEntries(subdir, "*.nupkg", SearchOption.TopDirectoryOnly);
foreach (var package in nugetRequest.FilterOnTags(nupkgs.Select(nugetRequest.GetPackageByFilePath).Where(pkgItem => pkgItem != null).Select(pkg => pkg.Package)))
{
yield return(package);
}
}
}
public void GetDynamicOptions(string category, NuGetRequest request)
{
request.Debug("Calling '{0}::GetDynamicOptions' '{1}'", PackageProviderName, category);
switch ((category ?? string.Empty).ToLowerInvariant())
{
case "package":
request.YieldDynamicOption("FilterOnTag", Constants.OptionType.StringArray, false);
request.YieldDynamicOption("Contains", Constants.OptionType.String, false);
request.YieldDynamicOption("AllowPrereleaseVersions", Constants.OptionType.Switch, false);
break;
case "source":
request.YieldDynamicOption("ConfigFile", Constants.OptionType.String, false);
request.YieldDynamicOption("SkipValidate", Constants.OptionType.Switch, false);
break;
case "install":
request.YieldDynamicOption("Destination", Constants.OptionType.Path, true);
request.YieldDynamicOption("SkipDependencies", Constants.OptionType.Switch, false);
request.YieldDynamicOption("ContinueOnFailure", Constants.OptionType.Switch, false);
request.YieldDynamicOption("ExcludeVersion", Constants.OptionType.Switch, false);
request.YieldDynamicOption("PackageSaveMode", Constants.OptionType.String, false, new[] {
"nuspec", "nupkg", "nuspec;nupkg"
});
break;
}
}
/// <summary>
/// Returns the packages that are installed. This method is called when a user type get-package, install-package and uninstall-package.
/// </summary>
/// <param name="name">the package name to match. Empty or null means match everything</param>
/// <param name="requiredVersion">the specific version asked for. If this parameter is specified (ie, not null or empty string) then the minimum and maximum values are ignored</param>
/// <param name="minimumVersion">the minimum version of packages to return . If the <code>requiredVersion</code> parameter is specified (ie, not null or empty string) this should be ignored</param>
/// <param name="maximumVersion">the maximum version of packages to return . If the <code>requiredVersion</code> parameter is specified (ie, not null or empty string) this should be ignored</param>
/// <param name="request">An object passed in from the PackageManagement that contains functions that can be used to interact with its Provider</param>
public void GetInstalledPackages(string name, string requiredVersion, string minimumVersion, string maximumVersion, NuGetRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Debug(Resources.Messages.DebugInfoCallMethod, PackageProviderName, string.Format(CultureInfo.InvariantCulture, "GetInstalledPackages' - name='{0}', requiredVersion='{1}',minimumVersion='{2}', maximumVersion='{3}'", name, requiredVersion, minimumVersion, maximumVersion));
// In the case of the package name is null or contains wildcards, error out if a user puts version info
if (!String.IsNullOrWhiteSpace(requiredVersion) || !String.IsNullOrWhiteSpace(minimumVersion) || !String.IsNullOrWhiteSpace(maximumVersion))
{
// A user provides the version info but missing name
if (string.IsNullOrWhiteSpace(name))
{
request.Warning(Constants.Messages.MissingRequiredParameter, "name");
return;
}
// A user provides the version info but the name containing wildcards
if (WildcardPattern.ContainsWildcardCharacters(name))
{
return;
}
}
NormalizeVersion(request, ref requiredVersion, ref minimumVersion, ref maximumVersion);
request.GetInstalledPackages(name, requiredVersion, minimumVersion, maximumVersion);
}
/// <summary>
/// Downloads a remote package file to a local location.
/// </summary>
/// <param name="fastPackageReference"></param>
/// <param name="destLocation"></param>
/// <param name="request">An object passed in from the PackageManagement that contains functions that can be used to interact with its Provider</param>
public void DownloadPackage(string fastPackageReference, string destLocation, NuGetRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Debug(Resources.Messages.DebugInfoCallMethod3, PackageProviderName, fastPackageReference, destLocation);
// Enforce use of TLS 1.2 when sending request
var securityProtocol = System.Net.ServicePointManager.SecurityProtocol;
System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12;
try {
var pkgItem = request.GetPackageByFastpath(fastPackageReference);
if (pkgItem == null)
{
request.WriteError(ErrorCategory.InvalidArgument, fastPackageReference, Constants.Messages.UnableToResolvePackage);
return;
}
pkgItem.PackageSource.Repository.DownloadPackage(new PublicObjectView(pkgItem), destLocation, request);
} catch (Exception ex) {
ex.Dump(request);
request.WriteError(ErrorCategory.InvalidOperation, fastPackageReference, ex.Message);
} finally {
// Change back to user specified security protocol
System.Net.ServicePointManager.SecurityProtocol = securityProtocol;
}
}
/// <summary>
/// Performs one-time initialization of the $provider.
/// </summary>
/// <param name="request">An object passed in from the CORE that contains functions that can be used to interact with the CORE and HOST</param>
public void InitializeProvider(NuGetRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Debug(Resources.Messages.DebugInfoCallMethod, PackageProviderName, "InitializeProvider");
}
/// <summary>
/// Uninstalls a package
/// </summary>
/// <param name="fastPackageReference"></param>
/// <param name="request">
/// An object passed in from the CORE that contains functions that can be used to interact with the
/// CORE and HOST
/// </param>
public void UninstallPackage(string fastPackageReference, NuGetRequest request)
{
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::UninstallPackage' '{1}'", PackageProviderName, fastPackageReference);
var pkg = request.GetPackageByFastpath(fastPackageReference);
request.UninstallPackage(pkg);
}
/// <summary>
/// </summary>
/// <param name="request">
/// An object passed in from the CORE that contains functions that can be used to interact with the
/// CORE and HOST
/// </param>
public void ResolvePackageSources(NuGetRequest request)
{
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::ResolvePackageSources'", PackageProviderName);
foreach (var source in request.SelectedSources)
{
request.YieldPackageSource(source.Name, source.Location, source.Trusted, source.IsRegistered, source.IsValidated);
}
}
public void InitializeProvider(NuGetRequest request)
{
Features.AddOrSet("exe", new[] {
Assembly.GetAssembly(typeof(PackageSource)).Location
});
// create a strongly-typed request object.
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::InitializeProvider'", PackageProviderName);
}
public NuGetSearchResult Search(NuGetSearchContext searchContext, NuGetRequest nugetRequest)
{
nugetRequest.Debug(Messages.DebugInfoCallMethod, "NuGetSearchFeed2", "Search");
if (nugetRequest == null)
{
return(searchContext.MakeResult());
}
return(Search(searchContext, new RequestWrapper(nugetRequest)));
}
/// <summary>
/// Find-Package bases on the given package Id
/// </summary>
/// <param name="packageId">Package Id</param>
/// <param name="request"></param>
/// <returns></returns>
public IEnumerable <IPackage> FindPackagesById(string packageId, NuGetRequest request)
{
request.Debug(Messages.DebugInfoCallMethod3, "HttpClientPackageRepository", "FindPackagesById", packageId);
var query = packageId.MakeFindPackageByIdQuery(_nugetFindPackageIdQueryFormat);
//request.Verbose(query.ToString());
return(NuGetClient.FindPackage(query, request));
}
/// <summary>
/// Installs a given package.
/// </summary>
/// <param name="fastPackageReference">A provider supplied identifier that specifies an exact package</param>
/// <param name="request">An object passed in from the PackageManagement that contains functions that can be used to interact with its Provider</param>
public void InstallPackage(string fastPackageReference, NuGetRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Debug(Resources.Messages.DebugInfoCallMethod3, PackageProviderName, "InstallPackage", fastPackageReference);
try {
var pkgItem = request.GetPackageByFastpath(fastPackageReference);
if (pkgItem == null)
{
request.WriteError(ErrorCategory.InvalidArgument, fastPackageReference, Constants.Messages.UnableToResolvePackage);
return;
}
if ((pkgItem.PackageSource == null) || (pkgItem.PackageSource.Location == null) || (pkgItem.Package == null))
{
request.Debug(Resources.Messages.VariableCheck, "PackageSource or PackageSource.Location or Package object", "null");
request.WriteError(ErrorCategory.ObjectNotFound, fastPackageReference, Constants.Messages.UnableToResolvePackage, pkgItem.Id);
return;
}
request.Debug(Resources.Messages.VariableCheck, "Package version", pkgItem.Version);
request.Debug(Resources.Messages.VariableCheck, "Request's Destination", request.Destination);
// got this far, let's install the package we came here for.
if (!NuGetClient.InstallOrDownloadPackageHelper(pkgItem, request, Constants.Install,
(packageItem, progressTracker) => NuGetClient.InstallSinglePackage(packageItem, request, progressTracker)))
{
// package itself didn't install. Write error
request.WriteError(ErrorCategory.InvalidResult, pkgItem.Id, Constants.Messages.PackageFailedInstallOrDownload, pkgItem.Id, CultureInfo.CurrentCulture.TextInfo.ToLower(Constants.Install));
return;
}
} catch (Exception ex) {
ex.Dump(request);
request.WriteError(ErrorCategory.InvalidOperation, fastPackageReference, ex.Message);
}
}
/// <summary>
/// Finds a package given a local filename
/// </summary>
/// <param name="file"></param>
/// <param name="id"></param>
/// <param name="request"></param>
public void FindPackageByFile(string file, int id, NuGetRequest request)
{
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::FindPackageByFile' '{1}','{2}'", PackageProviderName, file, id);
var pkgItem = request.GetPackageByFilePath(Path.GetFullPath(file));
if (pkgItem != null)
{
request.YieldPackage(pkgItem, file);
}
}
/// <summary>
/// Uninstalls a package
/// </summary>
/// <param name="fastPackageReference"></param>
/// <param name="request">An object passed in from the PackageManagement that contains functions that can be used to interact with its Provider</param>
public void UninstallPackage(string fastPackageReference, NuGetRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Debug(Resources.Messages.DebugInfoCallMethod3, PackageProviderName, "UninstallPackage", fastPackageReference);
var pkg = request.GetPackageByFastpath(fastPackageReference);
NuGetClient.UninstallPackage(request, pkg);
}
public IPackage FindPackage(NuGetSearchContext findContext, NuGetRequest request)
{
request.Debug(Messages.DebugInfoCallMethod3, "NuGetPackageRepository", "FindPackage", findContext.PackageInfo.Id);
NuGetSearchResult result = this.ResourceProvider.PackagesFeed.Find(findContext, request);
if (result.Result != null)
{
return(result.Result.FirstOrDefault());
}
else
{
return(null);
}
}
/// <summary>
/// </summary>
/// <param name="fastPackageReference"></param>
/// <param name="request">
/// An object passed in from the CORE that contains functions that can be used to interact with the
/// CORE and HOST
/// </param>
public void InstallPackage(string fastPackageReference, NuGetRequest request)
{
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::InstallPackage' '{1}'", PackageProviderName, fastPackageReference);
var pkgRef = request.GetPackageByFastpath(fastPackageReference);
if (pkgRef == null)
{
request.Error(ErrorCategory.InvalidArgument, fastPackageReference, Constants.Messages.UnableToResolvePackage);
return;
}
// need to make sure that the original package's sources list is tried first.
request.OriginalSources = pkgRef.Sources;
var dependencies = request.GetUninstalledPackageDependencies(pkgRef).Reverse().ToArray();
int progressId = 0;
if (dependencies.Length > 0)
{
progressId = request.StartProgress(0, "Installing package '{0}'", pkgRef.GetCanonicalId(request));
}
var n = 0;
foreach (var d in dependencies)
{
request.Progress(progressId, (n * 100 / (dependencies.Length + 1)) + 1, "Installing dependent package '{0}'", d.GetCanonicalId(request));
if (!request.InstallSinglePackage(d))
{
request.Error(ErrorCategory.InvalidResult, pkgRef.GetCanonicalId(request), Constants.Messages.DependentPackageFailedInstall, d.GetCanonicalId(request));
return;
}
n++;
request.Progress(progressId, (n * 100 / (dependencies.Length + 1)), "Installed dependent package '{0}'", d.GetCanonicalId(request));
}
// got this far, let's install the package we came here for.
if (!request.InstallSinglePackage(pkgRef))
{
// package itself didn't install.
// roll that back out everything we did install.
// and get out of here.
request.Error(ErrorCategory.InvalidResult, pkgRef.GetCanonicalId(request), Constants.Messages.PackageFailedInstall, pkgRef.GetCanonicalId(request));
request.CompleteProgress(progressId, false);
}
request.CompleteProgress(progressId, true);
}
/// <summary>
/// Search the entire repository for the case when a user does not provider package name or uses wildcards in the name.
/// </summary>
/// <param name="searchTerm"></param>
/// <param name="nugetRequest"></param>
/// <returns></returns>
public IEnumerable <IPackage> Search(string searchTerm, NuGetRequest nugetRequest)
{
if (nugetRequest == null)
{
yield break;
}
nugetRequest.Debug(Messages.DebugInfoCallMethod3, "HttpClientPackageRepository", "Search", searchTerm);
var searchQuery = searchTerm.MakeSearchQuery(_queryUri, nugetRequest.AllowPrereleaseVersions.Value, nugetRequest.AllVersions.Value);
foreach (var pkg in SendRequest(searchQuery, nugetRequest))
{
yield return(pkg);
}
}
/// <summary>
/// Removes/Unregisters a package source
/// </summary>
/// <param name="name">The name or location of a package source to remove.</param>
/// <param name="request">
/// An object passed in from the CORE that contains functions that can be used to interact with the
/// CORE and HOST
/// </param>
public void RemovePackageSource(string name, NuGetRequest request)
{
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::RemovePackageSource' '{1}'", PackageProviderName, name);
var src = request.FindRegisteredSource(name);
if (src == null)
{
request.Warning(Constants.Messages.UnableToResolveSource, name);
return;
}
request.RemovePackageSource(src.Name);
request.YieldPackageSource(src.Name, src.Location, src.Trusted, false, src.IsValidated);
}
/// <summary>
/// Finds packages given a locally-accessible filename
///
/// Package information must be returned using <c>request.YieldPackage(...)</c> function.
/// </summary>
/// <param name="file">the full path to the file to determine if it is a package</param>
/// <param name="id">if this is greater than zero (and the number should have been generated using <c>StartFind(...)</c>, the core is calling this multiple times to do a batch search request. The operation can be delayed until <c>CompleteFind(...)</c> is called</param>
/// <param name="request">An object passed in from the PackageManagement that contains functions that can be used to interact with its Provider</param>
public void FindPackageByFile(string file, int id, NuGetRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Debug(Resources.Messages.DebugInfoCallMethod3, PackageProviderName, file, id);
var pkgItem = request.GetPackageByFilePath(Path.GetFullPath(file));
if (pkgItem != null)
{
request.YieldPackage(pkgItem, file);
}
}
public bool SearchPackages(string name, string requiredVersion, string minimumVersion, string maximumVersion, bool minInclusive, bool maxInclusive, int id, NuGetRequest request)
{
try {
// If there are any packages, yield and return
if (request.YieldPackages(request.GetPackageById(name, request, requiredVersion, minimumVersion, maximumVersion, minInclusive, maxInclusive), name))
{
return(true);
}
// Check if the name contains wildcards. If not, return. This matches the behavior as "Get-module xje"
if (!String.IsNullOrWhiteSpace(name) && !WildcardPattern.ContainsWildcardCharacters(name))
{
return(false);
}
// In the case of the package name is null or contains wildcards, error out if a user puts version info
if (!String.IsNullOrWhiteSpace(requiredVersion) || !String.IsNullOrWhiteSpace(minimumVersion) || !String.IsNullOrWhiteSpace(maximumVersion))
{
request.Warning(Constants.Messages.MissingRequiredParameter, "name");
return(false);
}
// Have we been cancelled?
if (request.IsCanceled)
{
request.Debug(Resources.Messages.RequestCanceled, PackageProviderName, "FindPackage");
return(false);
}
// A user does not provide the package full Name at all Or used wildcard in the name. Let's try searching the entire repository for matches.
if (request.YieldPackages(request.SearchForPackages(name), name))
{
return(true);
}
}
catch (Exception ex)
{
ex.Dump(request);
}
return(false);
}
/// <summary>
/// Removes/Unregisters a package source
/// </summary>
/// <param name="name">The name or location of a package source to remove.</param>
/// <param name="request">An object passed in from the PackageManagement that contains functions that can be used to interact with its Provider</param>
public void RemovePackageSource(string name, NuGetRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Debug(Resources.Messages.DebugInfoCallMethod, PackageProviderName, "RemovePackageSource");
var src = request.FindRegisteredSource(name);
if (src == null)
{
request.Warning(Constants.Messages.UnableToResolveSource, name);
return;
}
request.RemovePackageSource(src.Name);
request.YieldPackageSource(src.Name, src.Location, src.Trusted, false, src.IsValidated);
}
/// <summary>
/// Find-Package
/// </summary>
/// <param name="packageId">package Id</param>
/// <param name="version">package version</param>
/// <param name="request"></param>
/// <returns></returns>
public IPackage FindPackage(string packageId, SemanticVersion version, NuGetRequest request)
{
if (string.IsNullOrWhiteSpace(packageId))
{
return(null);
}
request.Debug(Messages.DebugInfoCallMethod3, "HttpClientPackageRepository", "FindPackage", packageId);
var query = packageId.MakeFindPackageByIdQuery(_nugetFindPackageIdQueryFormat);
var packages = NuGetClient.FindPackage(query, request);
//Usually versions has a limited number, ToArray should be ok.
var versions = version.GetComparableVersionStrings().ToArray();
//Will only enumerate packages once
return(packages.FirstOrDefault(package => packageId.Equals(package.Id, StringComparison.OrdinalIgnoreCase) && versions.Contains(package.Version, StringComparer.OrdinalIgnoreCase)));
}
/// <summary>
/// Downloads a remote package file to a local location.
/// </summary>
/// <param name="fastPackageReference"></param>
/// <param name="location"></param>
/// <param name="request">
/// An object passed in from the CORE that contains functions that can be used to interact with the
/// CORE and HOST
/// </param>
/// <returns></returns>
public void DownloadPackage(string fastPackageReference, string location, NuGetRequest request)
{
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::DownloadPackage' '{1}','{2}'", PackageProviderName, fastPackageReference, location);
var pkgRef = request.GetPackageByFastpath(fastPackageReference);
if (pkgRef == null)
{
request.Error(ErrorCategory.InvalidArgument, fastPackageReference, Constants.Messages.UnableToResolvePackage);
return;
}
// cheap and easy copy to location.
using (var input = pkgRef.Package.GetStream()) {
using (var output = new FileStream(location, FileMode.Create, FileAccess.Write, FileShare.Read)) {
input.CopyTo(output);
}
}
}
/// <summary>
/// Find-Package
/// </summary>
/// <param name="openPackage">Delegate function which is actually finding a package</param>
/// <param name="packageId">Package Id</param>
/// <param name="version">Package version</param>
/// <param name="nugetRequest"></param>
/// <returns></returns>
private IPackage FindPackage(Func <string, Request, IPackage> openPackage, string packageId, SemanticVersion version, NuGetRequest nugetRequest)
{
if (nugetRequest == null)
{
return(null);
}
nugetRequest.Debug(Resources.Messages.SearchingRepository, "FindPackage", packageId);
var lookupPackageName = new PackageName(packageId, version);
//handle file cache here if we want to support local package cache later
// Lookup files which start with the name "<Id>." and attempt to match it with all possible version string combinations (e.g. 1.2.0, 1.2.0.0)
// before opening the package. To avoid creating file name strings, we attempt to specifically match everything after the last path separator
// which would be the file name and extension.
return((from path in GetPackageLookupPaths(packageId, version)
let package = GetPackage(openPackage, path, nugetRequest)
where lookupPackageName.Equals(new PackageName(package.Id, package.Version))
select package).FirstOrDefault());
}
/// <summary>
/// Downloads a remote package file to a local location.
/// </summary>
/// <param name="fastPackageReference"></param>
/// <param name="destLocation"></param>
/// <param name="request">An object passed in from the PackageManagement that contains functions that can be used to interact with its Provider</param>
public void DownloadPackage(string fastPackageReference, string destLocation, NuGetRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Debug(Resources.Messages.DebugInfoCallMethod3, PackageProviderName, fastPackageReference, destLocation);
try {
var pkgItem = request.GetPackageByFastpath(fastPackageReference);
if (pkgItem == null)
{
request.WriteError(ErrorCategory.InvalidArgument, fastPackageReference, Constants.Messages.UnableToResolvePackage);
return;
}
pkgItem.PackageSource.Repository.DownloadPackage(new PublicObjectView(pkgItem), destLocation, request);
} catch (Exception ex) {
ex.Dump(request);
request.WriteError(ErrorCategory.InvalidOperation, fastPackageReference, ex.Message);
}
}
/// <summary>
/// Downloads a remote package file to a local location.
/// </summary>
/// <param name="fastPackageReference"></param>
/// <param name="destLocation"></param>
/// <param name="request">An object passed in from the PackageManagement that contains functions that can be used to interact with its Provider</param>
public void DownloadPackage(string fastPackageReference, string destLocation, NuGetRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Debug(Resources.Messages.DebugInfoCallMethod3, PackageProviderName, fastPackageReference, destLocation);
try {
var pkgItem = request.GetPackageByFastpath(fastPackageReference);
if (pkgItem == null)
{
request.WriteError(ErrorCategory.InvalidArgument, fastPackageReference, Constants.Messages.UnableToResolvePackage);
return;
}
NuGetClient.InstallOrDownloadPackageHelper(pkgItem, request, Constants.Download,
(packageItem, progressTracker) => NuGetClient.DownloadSinglePackage(packageItem, request, destLocation, progressTracker));
} catch (Exception ex) {
ex.Dump(request);
request.WriteError(ErrorCategory.InvalidOperation, fastPackageReference, ex.Message);
}
}
/// <summary>
/// Searches package sources given name and version information
///
/// Package information must be returned using <c>request.YieldPackage(...)</c> function.
/// </summary>
/// <param name="name">a name or partial name of the package(s) requested</param>
/// <param name="requiredVersion">A specific version of the package. Null or empty if the user did not specify</param>
/// <param name="minimumVersion">A minimum version of the package. Null or empty if the user did not specify</param>
/// <param name="maximumVersion">A maximum version of the package. Null or empty if the user did not specify</param>
/// <param name="id">if this is greater than zero (and the number should have been generated using <c>StartFind(...)</c>, the core is calling this multiple times to do a batch search request. The operation can be delayed until <c>CompleteFind(...)</c> is called</param>
/// <param name="request">An object passed in from the PackageManagement that contains functions that can be used to interact with its Provider</param>
public void FindPackage(string name, string requiredVersion, string minimumVersion, string maximumVersion, int id, NuGetRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
// true if we want to include the max and min version
bool minInclusive = true;
bool maxInclusive = true;
// If finding by canonical id, then the version follows dependency version requirement
if (request.GetOptionValue("FindByCanonicalId").IsTrue())
{
// Use the dependency version if no min and max is supplied
if (String.IsNullOrWhiteSpace(maximumVersion) && String.IsNullOrWhiteSpace(minimumVersion))
{
DependencyVersion depVers = DependencyVersion.ParseDependencyVersion(requiredVersion);
maximumVersion = depVers.MaxVersion.ToStringSafe();
minimumVersion = depVers.MinVersion.ToStringSafe();
minInclusive = depVers.IsMinInclusive;
maxInclusive = depVers.IsMaxInclusive;
// set required version if we have both min max as the same value.
if (depVers.MaxVersion != null && depVers.MinVersion != null &&
depVers.MaxVersion == depVers.MinVersion && minInclusive && maxInclusive)
{
requiredVersion = maximumVersion;
}
else
{
requiredVersion = null;
}
}
}
request.Debug(Resources.Messages.DebugInfoCallMethod, PackageProviderName, string.Format(CultureInfo.InvariantCulture, "FindPackage' - name='{0}', requiredVersion='{1}',minimumVersion='{2}', maximumVersion='{3}'", name, requiredVersion, minimumVersion, maximumVersion));
NormalizeVersion(request, ref requiredVersion, ref minimumVersion, ref maximumVersion);
try {
// If there are any packages, yield and return
if (request.YieldPackages(request.GetPackageById(name, request, requiredVersion, minimumVersion, maximumVersion, minInclusive, maxInclusive), name))
{
return;
}
// Check if the name contains wildcards. If not, return. This matches the behavior as "Get-module xje"
if (!String.IsNullOrWhiteSpace(name) && !WildcardPattern.ContainsWildcardCharacters(name))
{
return;
}
// In the case of the package name is null or contains wildcards, error out if a user puts version info
if (!String.IsNullOrWhiteSpace(requiredVersion) || !String.IsNullOrWhiteSpace(minimumVersion) || !String.IsNullOrWhiteSpace(maximumVersion))
{
request.Warning(Constants.Messages.MissingRequiredParameter, "name");
return;
}
// Have we been cancelled?
if (request.IsCanceled)
{
request.Debug(Resources.Messages.RequestCanceled, PackageProviderName, "FindPackage");
return;
}
// A user does not provide the package full Name at all Or used wildcard in the name. Let's try searching the entire repository for matches.
request.YieldPackages(request.SearchForPackages(name), name);
}
catch (Exception ex)
{
ex.Dump(request);
}
}
