public LocalPackageInfo AddPackage(LocalPackageInfo package) { var ct = CancellationToken.None; var destPackageDir = _pathResolver.GetPackageDirectory(package.Identity.Id, package.Identity.Version); var destPackagePath = _pathResolver.GetPackageFilePath(package.Identity.Id, package.Identity.Version); _fileSystem.MakeDirectoryForFile(destPackagePath); using (var downloader = new LocalPackageArchiveDownloader(package.Path, package.Identity, _logAdapter)) { downloader.CopyNupkgFileToAsync(destPackagePath, ct).Wait(); var hashFilePath = Path.ChangeExtension(destPackagePath, PackagingCoreConstants.HashFileExtension); var hash = downloader.GetPackageHashAsync("SHA512", ct).Result; var hashBytes = Encoding.UTF8.GetBytes(hash); _fileSystem.AddFile(hashFilePath, hashFileStream => { hashFileStream.Write(hashBytes, 0, hashBytes.Length); }); var nuspecPath = _pathResolver.GetManifestFilePath(package.Identity.Id, package.Identity.Version); using (var nuspecStream = File.OpenWrite(nuspecPath)) { using (var fs = downloader.CoreReader.GetNuspecAsync(ct).Result) { fs.CopyTo(nuspecStream); } } _log.DebugFormat("Saved manifest {0}", nuspecPath); Lazy <NuspecReader> nuspecReader = new Lazy <NuspecReader>(() => new NuspecReader(nuspecPath)); var packageReader = new Func <PackageReaderBase>(() => new PackageArchiveReader(File.OpenRead(destPackagePath))); return(new LocalPackageInfo(package.Identity, destPackagePath, package.LastWriteTimeUtc, nuspecReader, packageReader)); } }
private static LockFileLibrary CreateLockFileLibrary(LocalPackageInfo package, string sha512, string path, string correctedPackageName) { var lockFileLib = new LockFileLibrary(); // package.Id is read from nuspec and it might be in wrong casing. // correctedPackageName should be the package name used by dependency graph and // it has the correct casing that runtime needs during dependency resolution. lockFileLib.Name = correctedPackageName ?? package.Id; lockFileLib.Version = package.Version; lockFileLib.Type = LibraryType.Package; lockFileLib.Sha512 = sha512; // This is the relative path, appended to the global packages folder path. All // of the paths in the in the Files property should be appended to this path along // with the global packages folder path to get the absolute path to each file in the // package. lockFileLib.Path = path; using (var packageReader = new PackageFolderReader(package.ExpandedPath)) { // Get package files, excluding directory entries and OPC files // This is sorted before it is written out lockFileLib.Files = packageReader .GetFiles() .Where(file => IsAllowedLibraryFile(file)) .ToList(); } return(lockFileLib); }
public LocalPackageSearchMetadataFixture() { var pkgId = new PackageIdentity("nuget.psm.test", new NuGetVersion(0, 0, 1)); var pkg = new SimpleTestPackageContext(pkgId.Id, pkgId.Version.ToNormalizedString()); var nuspec = NuspecBuilder.Create() .WithPackageId(pkgId.Id) .WithPackageVersion(pkgId.Version.ToNormalizedString()) .WithIcon("icon.png") .Build(); pkg.Nuspec = XDocument.Parse(nuspec.ToString()); _testDirectory = TestDirectory.Create(); SimpleTestPackageUtility.CreatePackagesAsync(_testDirectory.Path, pkg).Wait(); var pkgPath = Path.Combine(_testDirectory.Path, $"{pkgId.Id}.{pkgId.Version.ToNormalizedString()}.nupkg"); var info = new LocalPackageInfo( identity: pkgId, path: pkgPath, lastWriteTimeUtc: DateTime.UtcNow, nuspec: new Lazy <Packaging.NuspecReader>(() => { var reader = new PackageArchiveReader(pkgPath); return(reader.NuspecReader); }), getPackageReader: () => new PackageArchiveReader(pkgPath)); TestData = new LocalPackageSearchMetadata(info); }
public void StopDownloadPackage(LocalPackageInfo package) { lock (syncLock) { // is really downloading? if (!downloads.Contains(package)) { return; } // update status if (package.DownloadStatus.IsDownloaded) { package.DownloadStatus.Data.SegmentsBitmap = null; } // mark as "don't resume download" package.DownloadStatus.Data.IsDownloading = false; packageRegistry.UpdateDownloadStatus(package); // stop UpdateQueue(package, isInterested: false); } DownloadStatusChange?.Invoke(new DownloadStatusChange() { Package = package, HasStopped = true }); }
private void Init() { localPackages = new Dictionary <Hash, LocalPackageInfo>(); var packageReferences = localPackageManager.ListPackages(deleteUnfinishedBuilds: true).ToArray(); var packagesInitData = new List <LocalPackageInfo>(); foreach (var pr in packageReferences) { PackageHashes hashes; PackageDownloadInfo download; PackageMeta meta; PackageSequenceInfo packageSequence; try { hashes = localPackageManager.ReadPackageHashesFile(pr); packageSequence = hashes.CreatePackageSequence(); download = localPackageManager.ReadPackageDownloadStatus(pr, packageSequence); meta = localPackageManager.ReadPackageMetadata(pr); var item = new LocalPackageInfo(pr, download, hashes, meta, packageSequence); packagesInitData.Add(item); } catch (Exception e) { logger.LogWarning(e, "Can't read package {0:s}", pr.Id); continue; } } UpdateLists(addToLocal: packagesInitData, removeFromLocal: null, addToDiscovered: Enumerable.Empty <DiscoveredPackage>()); }
/// <summary> /// Add a file to the repository. /// </summary> public void AddPackage(LocalPackageInfo package) { _logger.InfoFormat("Start adding package {0} {1}.", package.Identity.Id, package.Identity.Version); // if (IgnoreSymbolsPackages && package.IsSymbolsPackage()) // { // var message = string.Format("Package {0} is a symbols package (it contains .pdb files and a /src folder). The server is configured to ignore symbols packages.", package); // _logger.Error(message); // throw new InvalidOperationException(message); // } if (!AllowOverrideExistingPackageOnPush && Exists(package.Identity.Id, package.Identity.Version)) { var message = string.Format("Package {0} already exists. The server is configured to not allow overwriting packages that already exist.", package.Identity); _logger.Error(message); throw new InvalidOperationException(message); } using (LockAndSuppressFileSystemWatcher()) { // Copy to correct filesystem location package = _expandedPackageRepository.AddPackage(package); // Add to metadata store _serverPackageStore.Store(CreateServerPackage(package, EnableDelisting)); _logger.InfoFormat("Finished adding package {0} {1}.", package.Identity.Id, package.Identity.Version); } }
public async Task DeletePackageAsync(LocalPackageInfo packageInfo) { if (packageInfo == null) { throw new ArgumentNullException(nameof(packageInfo)); } // first mark for deletion Task waitForReleaseLocksTask; lock (packagesLock) { if (packageInfo.LockProvider.IsMarkedToDelete) { return; } waitForReleaseLocksTask = packageInfo.LockProvider.MarkForDelete(); } // notify we are deleting package (stop download) LocalPackageDeleting?.Invoke(packageInfo); // wait for all resources all unlocked await waitForReleaseLocksTask; // delete content localPackageManager.DeletePackage(packageInfo); // update collections UpdateLists(addToLocal: null, removeFromLocal: new[] { packageInfo }, addToDiscovered: null); // notify we have deleted package (stop download) LocalPackageDeleted?.Invoke(packageInfo); }
public static async Task <License> GetLicenseAsync(this LocalPackageInfo info, ILogger log = null) { var licenseUrl = info.Nuspec.GetLicenseUrl(); if (!string.IsNullOrWhiteSpace(licenseUrl) && Uri.IsWellFormedUriString(licenseUrl, UriKind.Absolute)) { var license = await new Uri(licenseUrl).GetLicenseAsync(log); if (license != null) { return(license); } } var projectUrl = info.Nuspec.GetProjectUrl(); if (!string.IsNullOrWhiteSpace(projectUrl) && Uri.IsWellFormedUriString(projectUrl, UriKind.Absolute)) { var license = await new Uri(projectUrl).GetLicenseAsync(log); if (license != null) { return(license); } } return(null); }
public void InterestedInPackage(LocalPackageInfo packageInfo) { logger.LogDebug("Started looking for peers having: {0}", packageInfo); lock (syncLock) { if (states.ContainsKey(packageInfo.Id)) { return; // already there } var status = new PackagePeersStatus(loggerFactory.CreateLogger <PackagePeersStatus>(), packageInfo); states.Add(packageInfo.Id, status); // add status for each peer that knows package int alreadyFound = 0; foreach (var peer in peers.Values) { if (!peer.PeerInfo.KnownPackages.TryGetValue(packageInfo.Id, out PackageStatus ps)) { continue; } alreadyFound++; status.AddPeer(peer, isSeeder: ps.IsSeeder); } } // update status if needed TryRunStatusCallbackNow(); }
private async Task DeletePackage(LocalPackageInfo package, NuGetFramework projectFramework, string installPath, ILogger logger, CancellationToken token) { logger.LogInformation($"Deleting package '{package.Identity}'."); using (var packageReader = package.GetReader()) { foreach (var plugin in PackageManagerPlugins) { var accepted = await plugin.OnPackageUninstallingAsync(package.Identity, projectFramework, packageReader, installPath); if (!accepted) continue; } foreach (var file in await packageReader.GetPackageFilesAsync(PackageSaveMode, token)) { var path = Path.Combine(installPath, file); FileUtility.Delete(path); } } FileUtility.Delete(package.Path); var installTree = new DirectoryInfo(installPath); DeleteDirectoryTree(installTree); foreach (var plugin in PackageManagerPlugins) { await plugin.OnPackageUninstalledAsync(package.Identity, projectFramework, null, installPath); } }
private void ProcessArchiveForNuGetAPIsUsedInScripts(LocalPackageInfo packageInfo) { using (var archive = ZipFile.Open(packageInfo.Path, ZipArchiveMode.Read)) { var scriptFiles = archive.Entries .Where(e => e.FullName.EndsWith(".ps1", StringComparison.OrdinalIgnoreCase) || e.FullName.EndsWith(".psm1", StringComparison.OrdinalIgnoreCase)); if (scriptFiles.Count() > 0) { var packageIdentity = packageInfo.Identity; var pathResolver = new VersionFolderPathResolver(_outputPath); var writeDir = Path.Combine(_outputPath, pathResolver.GetPackageDirectory(packageIdentity.Id, packageIdentity.Version)); Directory.CreateDirectory(writeDir); foreach (var scriptFile in scriptFiles) { var path = Path.Combine(writeDir, Guid.NewGuid().ToString() + scriptFile.Name); scriptFile.ExtractToFile(path, true); using (var stream = scriptFile.Open()) using (var reader = new StreamReader(stream)) { var scriptFileContent = reader.ReadToEnd(); if (scriptFileContent.Contains("NuGet.VisualStudio.IFileSystemProvider") || scriptFileContent.Contains("NuGet.VisualStudio.ISolutionManager")) { AddToPackageCollection(packageIdentity, scriptFile.FullName, ""); } } } } } }
public static string GetPackageAssemblySearchPath( LocalPackageInfo packageInfo, NuGetFramework framework) { if (packageInfo == null) { return(null); } if (framework == null) { throw new ArgumentNullException(nameof(framework)); } var possibleFrameworks = packageInfo.Files .Select(path => path.Split(new [] { '/', '\\' })) .Where(parts => string.Equals(parts [0], "lib", StringComparison.OrdinalIgnoreCase)) .Select(parts => NuGetFramework.ParseFolder(parts [1].ToLowerInvariant())) .Distinct(); var bestFramework = new FrameworkReducer() .GetNearest(framework, possibleFrameworks); return(Path.Combine( packageInfo.ExpandedPath, "lib", bestFramework.GetShortFolderName())); }
private static LockFileLibrary CreateLockFileLibrary(LocalPackageInfo package, string sha512, string path) { var lockFileLib = new LockFileLibrary(); lockFileLib.Name = package.Id; lockFileLib.Version = package.Version; lockFileLib.Type = LibraryType.Package; lockFileLib.Sha512 = sha512; // This is the relative path, appended to the global packages folder path. All // of the paths in the in the Files property should be appended to this path along // with the global packages folder path to get the absolute path to each file in the // package. lockFileLib.Path = path; using (var packageReader = new PackageFolderReader(package.ExpandedPath)) { // Get package files, excluding directory entries and OPC files // This is sorted before it is written out lockFileLib.Files = packageReader .GetFiles() .Where(file => IsAllowedLibraryFile(file)) .ToList(); } return(lockFileLib); }
private LocalPackageInfo FindCandidate(string name, NuGetVersionRange versionRange) { var packages = _repository.FindPackagesById(name); if (versionRange == null) { // TODO: Disallow null versions for nuget packages var packageInfo = packages.FirstOrDefault(); if (packageInfo != null) { return(packageInfo); } return(null); } LocalPackageInfo bestMatch = null; foreach (var packageInfo in packages) { if (versionRange.IsBetter( current: bestMatch?.Version, considering: packageInfo.Version)) { bestMatch = packageInfo; } } if (bestMatch == null) { return(null); } return(bestMatch); }
public Dictionary <string, string> Execute(ZipArchive archive, LocalPackageInfo localPackage) { var results = new Dictionary <string, string>();; var ps1Files = archive.Entries .Where(e => e.FullName.EndsWith(".ps1", StringComparison.OrdinalIgnoreCase)) .ToArray(); var ps1FilesContainingNuGetAPIs = new List <string>(); if (ps1Files.Count() > 0) { foreach (var scriptFile in ps1Files) { var path = GetRandomPath(); scriptFile.ExtractToFile(path, true); using (var stream = scriptFile.Open()) using (var reader = new StreamReader(stream)) { var scriptFileContent = reader.ReadToEnd(); if (scriptFileContent.Contains("NuGet.VisualStudio.IFileSystemProvider") || scriptFileContent.Contains("NuGet.VisualStudio.ISolutionManager")) { ps1FilesContainingNuGetAPIs.Add(scriptFile.FullName); } } } } results.Add(Constants.PS1ScriptsWithNuGetAPIs, string.Join(";", ps1FilesContainingNuGetAPIs)); return(results); }
private static LockFileLibrary CreateLockFileLibrary(LocalPackageInfo package, string sha512, string path) { var lockFileLib = new LockFileLibrary { Name = package.Id, Version = package.Version, Type = LibraryType.Package, Sha512 = sha512, // This is the relative path, appended to the global packages folder path. All // of the paths in the in the Files property should be appended to this path along // with the global packages folder path to get the absolute path to each file in the // package. Path = path }; foreach (var file in package.Files) { if (!lockFileLib.HasTools && HasTools(file)) { lockFileLib.HasTools = true; } lockFileLib.Files.Add(file); } return(lockFileLib); }
/// <summary> /// Get a ContentItemCollection of the package files. /// </summary> /// <remarks>Library is optional.</remarks> public ContentItemCollection GetContentItems(LockFileLibrary library, LocalPackageInfo package) { if (package == null) { throw new ArgumentNullException(nameof(package)); } var identity = new PackageIdentity(package.Id, package.Version); if (!_contentItems.TryGetValue(identity, out var collection)) { collection = new ContentItemCollection(); if (library == null) { // Read folder collection.Load(package.Files); } else { // Use existing library collection.Load(library.Files); } _contentItems.Add(identity, collection); } return(collection); }
private IEnumerable <string> GetAssembliesForFramework(LocalPackageInfo package, NuGetFramework framework, IEnumerable <string> files) { var contentItems = new NuGet.ContentModel.ContentItemCollection(); HashSet <string> referenceFilter = null; contentItems.Load(files); // This will throw an appropriate error if the nuspec is missing var nuspec = package.Nuspec; IList <string> compileTimeAssemblies = null; IList <string> runtimeAssemblies = null; var referenceSet = nuspec.GetReferenceGroups().GetNearest(framework); if (referenceSet != null) { referenceFilter = new HashSet <string>(referenceSet.Items, StringComparer.OrdinalIgnoreCase); } var conventions = new ManagedCodeConventions(null); var managedCriteria = conventions.Criteria.ForFramework(framework); var compileGroup = contentItems.FindBestItemGroup(managedCriteria, conventions.Patterns.CompileAssemblies, conventions.Patterns.RuntimeAssemblies); if (compileGroup != null) { compileTimeAssemblies = compileGroup.Items.Select(t => t.Path).ToList(); } var runtimeGroup = contentItems.FindBestItemGroup(managedCriteria, conventions.Patterns.RuntimeAssemblies); if (runtimeGroup != null) { runtimeAssemblies = runtimeGroup.Items.Select(p => p.Path).ToList(); } // COMPAT: Support lib/contract so older packages can be consumed var contractPath = "lib/contract/" + package.Id + ".dll"; var hasContract = files.Any(path => path == contractPath); var hasLib = runtimeAssemblies?.Any(); if (hasContract && hasLib.HasValue && hasLib.Value && !framework.IsDesktop()) { compileTimeAssemblies.Clear(); compileTimeAssemblies.Add(contractPath); } // Apply filters from the <references> node in the nuspec if (referenceFilter != null) { // Remove anything that starts with "lib/" and is NOT specified in the reference filter. // runtimes/* is unaffected (it doesn't start with lib/) compileTimeAssemblies = compileTimeAssemblies.Where(p => !p.StartsWith("lib/") || referenceFilter.Contains(Path.GetFileName(p))).ToList(); } return(compileTimeAssemblies ?? Enumerable.Empty <string>()); }
private static XElement GeneratePackagePathProperty(LocalPackageInfo localPackageInfo) { #if NETCOREAPP return(GenerateProperty($"Pkg{localPackageInfo.Id.Replace(".", "_", StringComparison.Ordinal)}", localPackageInfo.ExpandedPath)); #else return(GenerateProperty($"Pkg{localPackageInfo.Id.Replace(".", "_")}", localPackageInfo.ExpandedPath)); #endif }
public static LockFileTargetLibrary CreateLockFileTargetLibrary( LockFileLibrary library, LocalPackageInfo package, RestoreTargetGraph targetGraph, LibraryIncludeFlags dependencyType, NuGetFramework targetFrameworkOverride, IEnumerable <LibraryDependency> dependencies) { LockFileTargetLibrary lockFileLib = null; var framework = targetFrameworkOverride ?? targetGraph.Framework; var runtimeIdentifier = targetGraph.RuntimeIdentifier; // Read files from package var files = GetPackageFiles(library, package); var contentItems = new ContentItemCollection(); contentItems.Load(files); // This will throw an appropriate error if the nuspec is missing var nuspec = package.Nuspec; // Create fallback criteria, this will always be one or more. var orderedCriteriaSets = CreateOrderedCriteriaSets(targetGraph, framework); for (var i = 0; i < orderedCriteriaSets.Count; i++) { // Create a new library each time to avoid // assets being added from other criteria. lockFileLib = new LockFileTargetLibrary() { Name = package.Id, Version = package.Version, Type = LibraryType.Package }; // Populate assets AddAssets(library, package, targetGraph, dependencyType, lockFileLib, framework, runtimeIdentifier, files, contentItems, nuspec, orderedCriteriaSets[i]); // Check if compatile assets were found. // If no compatible assets were found and this is the last check // continue on with what was given, this will fail in the normal // compat verification. if (CompatibilityChecker.HasCompatibleAssets(lockFileLib)) { // Stop when compatible assets are found. break; } } // Add dependencies AddDependencies(dependencies, lockFileLib, framework, nuspec); // Exclude items ExcludeItems(lockFileLib, dependencyType); return(lockFileLib); }
public ServerPackage CreateServerPackage(LocalPackageInfo package, bool enableDelisting) { // File names var packageFileName = package.Path; var hashFileName = Path.ChangeExtension(packageFileName, PackagingCoreConstants.HashFileExtension); // File system var physicalFileSystem = _fileSystem as PhysicalFileSystem; // Build package info var packageDerivedData = new PackageDerivedData(); // Read package hash using (var reader = new StreamReader(_fileSystem.OpenFile(hashFileName))) { packageDerivedData.PackageHash = reader.ReadToEnd().Trim(); } // Read package info var localPackage = package; if (physicalFileSystem != null) { // Read package info from file system var fileInfo = new FileInfo(packageFileName); packageDerivedData.PackageSize = fileInfo.Length; packageDerivedData.LastUpdated = _fileSystem.GetLastModified(packageFileName); packageDerivedData.Created = _fileSystem.GetCreated(packageFileName); packageDerivedData.Path = packageFileName; packageDerivedData.FullPath = fileInfo.FullName; // if (enableDelisting && localPackage != null) // { // // hidden packages are considered delisted // localPackage.Listed = !fileInfo.Attributes.HasFlag(FileAttributes.Hidden); // } } else { throw new NotSupportedException("Read package info from package (slower)"); // FIXME Read package info from package (slower) // using (var stream = package.GetStream()) // { // packageDerivedData.PackageSize = stream.Length; // } // packageDerivedData.LastUpdated = DateTime.MinValue; // packageDerivedData.Created = DateTime.MinValue; } // TODO: frameworks? // Build entry var serverPackage = new ServerPackage(package.Nuspec, packageDerivedData); return(serverPackage); }
public bool IsPackageInstalled(LocalPackageInfo package) { var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder); var installedPath = packagePathResolver.GetInstalledPath(package.Identity); PackageReaderBase packageReader; packageReader = new PackageFolderReader(installedPath); var libItems = packageReader.GetLibItems(); var frameworkReducer = new FrameworkReducer(); var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework)); var files = libItems .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items).ToList(); foreach (var f in files) { string source = ""; string f2 = ""; string filename = ""; string dir = ""; string target = ""; try { source = System.IO.Path.Combine(installedPath, f); f2 = f.Substring(f.IndexOf("/", 4) + 1); filename = System.IO.Path.GetFileName(f2); dir = System.IO.Path.GetDirectoryName(f2); target = System.IO.Path.Combine(Destinationfolder, dir, filename); if (!System.IO.Directory.Exists(System.IO.Path.Combine(Destinationfolder, dir))) { System.IO.Directory.CreateDirectory(System.IO.Path.Combine(Destinationfolder, dir)); } if (!System.IO.File.Exists(source)) { return(false); } if (!System.IO.File.Exists(target)) { return(false); } var infoOld = new System.IO.FileInfo(source); var infoNew = new System.IO.FileInfo(target); if (infoNew.LastWriteTime != infoOld.LastWriteTime) { return(false); } } catch (Exception ex) { Console.WriteLine(ex.ToString()); } } return(true); }
public Dictionary <string, string> Execute(ZipArchive archive, LocalPackageInfo localPackage) { var results = new Dictionary <string, string>();; var xdtFiles = archive.Entries.Where(e => e.FullName.EndsWith(".xdt", StringComparison.OrdinalIgnoreCase)); results.Add(Constants.XdtFiles, string.Join(";", xdtFiles)); return(results); }
public Dictionary <string, string> Execute(ZipArchive archive, LocalPackageInfo localPackage) { var results = new Dictionary <string, string>();; var ppFiles = archive.Entries.Where(e => e.FullName.EndsWith(".pp")); results.Add(Constants.PPFiles, string.Join(";", ppFiles)); return(results); }
private void RegisterPackageInternal(LocalPackageInfo package) { lock (packagesLock) { if (localPackages.ContainsKey(package.Id)) { throw new InvalidOperationException("Registering package with existing hash."); } UpdateLists(addToLocal: new LocalPackageInfo[] { package }, removeFromLocal: null, addToDiscovered: null); } }
public Dictionary <string, string> Execute(ZipArchive archive, LocalPackageInfo localPackage) { var msbuildFiles = archive.Entries .Where(e => e.FullName.EndsWith(localPackage.Identity.Id + ".targets", StringComparison.OrdinalIgnoreCase) || e.FullName.EndsWith(localPackage.Identity.Id + ".props", StringComparison.OrdinalIgnoreCase)); var results = new Dictionary <string, string>();; results.Add(Constants.MSBuildFiles, string.Join(";", msbuildFiles)); return(results); }
public bool TryGetPackage(Hash packageHash, out LocalPackageInfo package) { lock (packagesLock) { if (!localPackages.TryGetValue(packageHash, out package)) { return(false); } return(true); } }
private void PrintCorruptedInstallInfo(LocalPackageInfo info) { using (Renderer.WithColor(ConsoleColor.Red)) { Renderer.WriteLine($" Installed version in {info.InstallFolder} is corrupted."); foreach (var file in info.Files) { Renderer.WriteLine($" - {Controller.GetDisplayPath(file.Path)} is {file.Status}"); } } }
public static LockFileTargetLibrary CreateLockFileTargetLibrary( LockFileLibrary library, LocalPackageInfo package, RestoreTargetGraph targetGraph, LibraryIncludeFlags dependencyType, NuGetFramework targetFrameworkOverride, IEnumerable <LibraryDependency> dependencies, LockFileBuilderCache cache) { return(CreateLockFileTargetLibrary(libraryDependency: null, library, package, targetGraph, dependencyType, targetFrameworkOverride, dependencies, cache)); }
public void AddLocalPackage(PackageIdentity identity, string localPath) { var newPackage = new LocalPackageInfo(identity.Id, identity.Version.ToString(), localPath); if (_localPackages.Contains(newPackage, LocalPackageInfo.IdVersionComparer.New)) { return; } _localPackages.Add(newPackage); }