| private YieldPackage ( PackageItem pkg, string searchKey, string destinationPath = null ) : bool | ||
| pkg | PackageItem | |
| searchKey | string | |
| destinationPath | string | |
| return | bool | |
/// <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);
}
}
/// <summary>
/// Returns the packages that are installed
/// </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 CORE that contains functions that can be used to interact with
/// the CORE and HOST
/// </param>
public void GetInstalledPackages(string name, string requiredVersion, string minimumVersion, string maximumVersion, NuGetRequest request)
{
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::GetInstalledPackages' '{1}','{2}','{3}','{4}'", PackageProviderName, name, requiredVersion, minimumVersion, maximumVersion);
if (requiredVersion != null) {
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;
}
// look in the destination directory for directories that contain nupkg files.
var subdirs = Directory.EnumerateDirectories(request.Destination);
foreach (var subdir in subdirs) {
var nupkgs = Directory.EnumerateFileSystemEntries(subdir, "*.nupkg", SearchOption.TopDirectoryOnly);
foreach (var pkgFile in nupkgs) {
var pkgItem = request.GetPackageByFilePath(pkgFile);
if (pkgItem != null && pkgItem.IsInstalled) {
if (pkgItem.Id.Equals(name, StringComparison.CurrentCultureIgnoreCase)) {
if (!string.IsNullOrWhiteSpace(requiredVersion)) {
if (pkgItem.Package.Version != new SemanticVersion(requiredVersion)) {
continue;
}
} else {
if (!string.IsNullOrWhiteSpace(minimumVersion) && pkgItem.Package.Version < new SemanticVersion(minimumVersion)) {
continue;
}
if (!string.IsNullOrWhiteSpace(maximumVersion) && pkgItem.Package.Version < new SemanticVersion(maximumVersion)) {
continue;
}
}
request.YieldPackage(pkgItem, name);
break;
}
if (string.IsNullOrEmpty(name) || pkgItem.Id.IndexOf(name, StringComparison.CurrentCultureIgnoreCase) > -1) {
if (!request.YieldPackage(pkgItem, name)) {
return;
}
}
}
}
}
}
/// <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>
/// Perform package uninstallation.
/// </summary>
/// <param name="request">Object given by the PackageManagement platform</param>
/// <param name="pkg">PackageItem object</param>
internal static void UninstallPackage(NuGetRequest request, PackageItem pkg)
{
request.Debug(Messages.DebugInfoCallMethod, "NuGetClient", "UninstallPackage");
if (pkg == null)
{
throw new ArgumentNullException(paramName: "pkg");
}
var dir = pkg.InstalledDirectory;
if (String.IsNullOrWhiteSpace(dir) || !Directory.Exists(dir))
{
return;
}
FileUtility.DeleteDirectory(pkg.InstalledDirectory, recursive:true, isThrow:false);
//Inform a user which package is deleted via the packageManagement platform
request.Verbose(Messages.UninstalledPackage, "NuGetClient", pkg.Id);
request.YieldPackage(pkg, pkg.Id);
}
/// <summary>
/// Download a single package to destination without checking for dependencies
/// </summary>
/// <param name="pkgItem"></param>
/// <param name="request"></param>
/// <param name="destLocation"></param>
/// <returns></returns>
internal static bool DownloadSinglePackage(PackageItem pkgItem, NuGetRequest request, string destLocation)
{
if (string.IsNullOrWhiteSpace(pkgItem.PackageFilename) || pkgItem.PackageSource == null || pkgItem.PackageSource.Location == null
|| (pkgItem.PackageSource.IsSourceAFile && pkgItem.Package == null))
{
request.WriteError(ErrorCategory.ObjectNotFound, pkgItem.Id, Constants.Messages.UnableToResolvePackage, pkgItem.Id);
return false;
}
// this is if the user says -force
bool force = request.GetOptionValue("Force") != null;
// combine the path and the file name
destLocation = Path.Combine(destLocation, pkgItem.PackageFilename);
// if the file already exists
if (File.Exists(destLocation))
{
// if no force, just return
if (!force)
{
request.Verbose(Constants.Messages.SkippedDownloadedPackage, pkgItem.Id);
request.YieldPackage(pkgItem, pkgItem.PackageSource.Name);
return true;
}
// here we know it is forced, so delete
FileUtility.DeleteFile(destLocation, isThrow: false);
// if after we try delete, it is still there, tells the user we can't perform the action
if (File.Exists(destLocation))
{
request.WriteError(ErrorCategory.ResourceUnavailable, destLocation, Constants.Messages.UnableToOverwriteExistingFile, destLocation);
return false;
}
}
try
{
if (pkgItem.PackageSource.Repository.IsFile)
{
using (var input = File.OpenRead(pkgItem.Package.FullFilePath))
{
using (var output = new FileStream(destLocation, FileMode.Create, FileAccess.Write, FileShare.Read))
{
input.CopyTo(output);
}
}
}
else
{
//V2 download package protocol:
//sample url: http://www.nuget.org/api/v2/package/jQuery/2.1.3
string append = String.Format(CultureInfo.InvariantCulture, "/package/{0}/{1}", pkgItem.Id, pkgItem.Version);
string httpquery = PathUtility.UriCombine(pkgItem.PackageSource.Repository.Source, append);
NuGetClient.DownloadPackage(pkgItem.Id, pkgItem.Version, destLocation,
string.IsNullOrWhiteSpace(pkgItem.Package.ContentSrcUrl) ? httpquery : pkgItem.Package.ContentSrcUrl, request);
}
}
catch (Exception ex)
{
ex.Dump(request);
return false;
}
request.Verbose(Resources.Messages.SuccessfullyDownloaded, pkgItem.Id);
request.YieldPackage(pkgItem, pkgItem.PackageSource.Name);
return true;
}
/// <summary>
/// Install a single package without checking for dependencies
/// </summary>
/// <param name="pkgItem"></param>
/// <param name="request"></param>
/// <returns></returns>
internal static bool InstallSinglePackage(PackageItem pkgItem, NuGetRequest request)
{
PackageItem packageToBeInstalled;
// 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(pkgItem.Id, new SemanticVersion(pkgItem.Version), request).FullFilePath;
packageToBeInstalled = NuGetClient.InstallPackageLocal(pkgItem.Id, pkgItem.Version, request, pkgItem.PackageSource, fileLocation);
}
else
{
//V2 download package protocol:
//sample url: http://www.nuget.org/api/v2/package/jQuery/2.1.3
string append = String.Format(CultureInfo.InvariantCulture, "/package/{0}/{1}", pkgItem.Id, pkgItem.Version);
string httpquery = PathUtility.UriCombine(pkgItem.PackageSource.Repository.Source, append);
// wait for the result from installpackage
packageToBeInstalled = NuGetClient.InstallPackage(pkgItem.Id, pkgItem.Version, request, pkgItem.PackageSource,
string.IsNullOrWhiteSpace(pkgItem.Package.ContentSrcUrl) ? httpquery : pkgItem.Package.ContentSrcUrl,
pkgItem.Package.PackageHash, pkgItem.Package.PackageHashAlgorithm);
}
// 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);
}
else
{
request.YieldPackage(packageToBeInstalled, packageToBeInstalled.PackageSource.Name);
}
request.Debug(Messages.DebugInfoReturnCall, "NuGetClient", "InstallSinglePackage");
return true;
}
return false;
}