/// <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); } }