private async Task <IVsPathContext> GetPathContextFromAssetsFileAsync( NuGetProject nuGetProject, CancellationToken token) { // It's possible that this project isn't a build integrated NuGet project at all. That is, this project may // be a packages.config project. var buildIntegratedProject = nuGetProject as BuildIntegratedNuGetProject; if (buildIntegratedProject == null) { return(null); } // It's possible the lock file doesn't exist or it's an older format that doesn't have the package folders // property persisted. var lockFile = await _getLockFileOrNullAsync(buildIntegratedProject); if (lockFile == null || lockFile.PackageFolders == null || lockFile.PackageFolders.Count == 0) { return(null); } // The user packages folder is always the first package folder. Subsequent package folders are always // fallback package folders. var packageFolders = lockFile .PackageFolders .Select(lockFileItem => lockFileItem.Path) .ToList(); var userPackageFolder = packageFolders[0]; var fallbackPackageFolders = packageFolders.Skip(1); if (lockFile.Libraries == null || lockFile.Libraries.Count == 0) { return(new VsPathContext(userPackageFolder, fallbackPackageFolders)); } var fppr = new FallbackPackagePathResolver(userPackageFolder, fallbackPackageFolders); var trie = new PathLookupTrie <string>(); foreach (var pid in lockFile .Libraries .Where(l => l.Type == LibraryType.Package) .Select(l => new PackageIdentity(l.Name, l.Version))) { var packageInstallPath = fppr.GetPackageDirectory(pid.Id, pid.Version); if (packageInstallPath != null) { trie[packageInstallPath] = packageInstallPath; } } return(new VsIndexedPathContext( userPackageFolder, fallbackPackageFolders, trie)); }
public static async Task ExecuteInitPs1ScriptsAsync( BuildIntegratedNuGetProject project, IEnumerable <PackageIdentity> packages, FallbackPackagePathResolver pathResolver, INuGetProjectContext projectContext) { // Find all dependencies in sorted order var sortedPackages = await BuildIntegratedProjectUtility.GetOrderedProjectPackageDependencies(project); // Keep track of the packages that need to be executed. var packagesToExecute = new HashSet <PackageIdentity>(packages, PackageIdentity.Comparer); // Use the ordered packages to run init.ps1 for the specified packages. foreach (var package in sortedPackages) { if (packagesToExecute.Remove(package)) { var packageInstallPath = pathResolver.GetPackageDirectory(package.Id, package.Version); if (packageInstallPath == null) { continue; } await project.ExecuteInitScriptAsync( package, packageInstallPath, projectContext, throwOnFailure : false); } } }
public void FallbackPackagePathResolver_MissingPackageWithFallbacks() { // Arrange using (var mockBaseDirectory = TestDirectory.Create()) { var userFolder = Path.Combine(mockBaseDirectory, "global"); var fallbackFolders = new List <string>() { Path.Combine(mockBaseDirectory, "fallback1"), Path.Combine(mockBaseDirectory, "fallback2"), }; Directory.CreateDirectory(userFolder); foreach (var fallback in fallbackFolders) { Directory.CreateDirectory(fallback); } var resolver = new FallbackPackagePathResolver(userFolder, fallbackFolders); // Act var path = resolver.GetPackageDirectory("a", "1.0.0"); // Assert Assert.Null(path); } }
private string GetPackageInstalledPath(PackageIdentity packageIdentity) { var nugetPaths = NuGetPathContext.Create(Settings); var fallbackResolver = new FallbackPackagePathResolver(nugetPaths); // Verify the package exists and return the path. Return null otherwise. return(fallbackResolver.GetPackageDirectory(packageIdentity.Id, packageIdentity.Version)); }
public IEnumerable <IVsPackageMetadata> GetInstalledPackages() { var packages = new HashSet <IVsPackageMetadata>(new VsPackageMetadataComparer()); return(NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate { // Calls may occur in the template wizard before the solution is actually created, // in that case return no projects if (_solutionManager != null && !string.IsNullOrEmpty(_solutionManager.SolutionDirectory)) { InitializePackageManagerAndPackageFolderPath(); foreach (var project in (await _solutionManager.GetNuGetProjectsAsync())) { FallbackPackagePathResolver pathResolver = null; var buildIntegratedProject = project as BuildIntegratedNuGetProject; if (buildIntegratedProject != null) { pathResolver = await GetPackagesPathResolverAsync(buildIntegratedProject); } var installedPackages = await project.GetInstalledPackagesAsync(CancellationToken.None); foreach (var package in installedPackages) { var identity = package.PackageIdentity; if (!identity.HasVersion) { // Currently we are not supporting floating versions // because of that we will skip this package continue; } // find packages using the solution level packages folder string installPath; if (buildIntegratedProject != null) { installPath = pathResolver.GetPackageDirectory(identity.Id, identity.Version); } else { installPath = _packageManager .PackagesFolderNuGetProject .GetInstalledPath(identity); } var metadata = new VsPackageMetadata(package.PackageIdentity, installPath); packages.Add(metadata); } } } return packages; })); }
private async Task <IVsPathContext> GetPathContextFromAssetsFileAsync( NuGetProject nuGetProject, CancellationToken token) { // It's possible that this project isn't a build integrated NuGet project at all. That is, this project may // be a packages.config project. var buildIntegratedProject = nuGetProject as BuildIntegratedNuGetProject; if (buildIntegratedProject == null) { return(null); } var lockFile = await _getLockFileOrNullAsync(buildIntegratedProject); if ((lockFile?.PackageFolders?.Count ?? 0) == 0) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, VsResources.PathContext_LockFileError)); } // The user packages folder is always the first package folder. Subsequent package folders are always // fallback package folders. var packageFolders = lockFile .PackageFolders .Select(lockFileItem => lockFileItem.Path) .ToList(); var userPackageFolder = packageFolders[0]; var fallbackPackageFolders = packageFolders.Skip(1); if (lockFile.Libraries == null || lockFile.Libraries.Count == 0) { return(new VsPathContext(userPackageFolder, fallbackPackageFolders)); } var fppr = new FallbackPackagePathResolver(userPackageFolder, fallbackPackageFolders); var trie = new PathLookupTrie <string>(); foreach (var pid in lockFile .Libraries .Where(l => l.Type == LibraryType.Package) .Select(l => new PackageIdentity(l.Name, l.Version))) { var packageInstallPath = fppr.GetPackageDirectory(pid.Id, pid.Version); if (string.IsNullOrEmpty(packageInstallPath)) { throw new KeyNotFoundException(string.Format(CultureInfo.CurrentCulture, VsResources.PathContext_PackageDirectoryNotFound, pid)); } trie[packageInstallPath] = packageInstallPath; } return(new VsIndexedPathContext( userPackageFolder, fallbackPackageFolders, trie)); }
public async Task FallbackPackagePathResolver_FindPackageInFallbackFolder2SkipMissingHashes() { // Arrange using (var mockBaseDirectory = TestDirectory.Create()) { var userFolder = Path.Combine(mockBaseDirectory, "global"); var fallbackFolders = new List <string>() { Path.Combine(mockBaseDirectory, "fallback1"), Path.Combine(mockBaseDirectory, "fallback2"), }; Directory.CreateDirectory(userFolder); foreach (var fallback in fallbackFolders) { Directory.CreateDirectory(fallback); } var saveMode = PackageSaveMode.Nuspec | PackageSaveMode.Files | PackageSaveMode.Nupkg; var targetFolder = fallbackFolders[1]; await SimpleTestPackageUtility.CreateFolderFeedV3Async( userFolder, saveMode, new PackageIdentity("a", NuGetVersion.Parse("1.0.0"))); await SimpleTestPackageUtility.CreateFolderFeedV3Async( fallbackFolders[0], saveMode, new PackageIdentity("a", NuGetVersion.Parse("1.0.0"))); await SimpleTestPackageUtility.CreateFolderFeedV3Async( fallbackFolders[1], saveMode, new PackageIdentity("a", NuGetVersion.Parse("1.0.0"))); // Remove hashes from the first two folders foreach (var root in new[] { userFolder, fallbackFolders[0] }) { var localResolver = new VersionFolderPathResolver(root); File.Delete(localResolver.GetHashPath("a", NuGetVersion.Parse("1.0.0"))); } var expected = Path.Combine(targetFolder, "a", "1.0.0"); var resolver = new FallbackPackagePathResolver(userFolder, fallbackFolders); // Act var path = resolver.GetPackageDirectory("a", "1.0.0"); // Assert Assert.Equal(expected, path); } }
public string GetPackageInstallPath(NuGetProject nugetProject, PackageIdentity package) { if (nugetProject is INuGetIntegratedProject) { return(pathResolver.GetPackageDirectory(package.Id, package.Version) ?? globalPackagesFolderResolver.GetInstallPath(package.Id, package.Version)); } return(folderNuGetProject.GetInstalledPath(package)); }
public string GetPackageDirectory(string packageId, NuGetVersion version, out string packageRoot) { packageRoot = null; var pkginfo = _packagePathResolver.GetPackageInfo(packageId, version); if (pkginfo != null) { packageRoot = pkginfo.PathResolver.GetVersionListPath(""); //TODO Remove Once Nuget is updated to use FallbackPackagePathInfo.PathResolver.RootPath } return(_packagePathResolver.GetPackageDirectory(packageId, version)); }
private async Task <IVsPathContext> GetPathContextFromProjectLockFileAsync( string lockFilePath, CancellationToken token) { var lockFile = _getLockFileOrNull(lockFilePath); if ((lockFile?.PackageFolders?.Count ?? 0) == 0) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, VsResources.PathContext_LockFileError)); } // switch to a background thread to process packages data await TaskScheduler.Default; // The user packages folder is always the first package folder. Subsequent package folders are always // fallback package folders. var packageFolders = lockFile .PackageFolders .Select(lockFileItem => lockFileItem.Path) .ToList(); var userPackageFolder = packageFolders[0]; var fallbackPackageFolders = packageFolders.Skip(1); if (lockFile.Libraries == null || lockFile.Libraries.Count == 0) { return(new VsPathContext(userPackageFolder, fallbackPackageFolders)); } var fppr = new FallbackPackagePathResolver(userPackageFolder, fallbackPackageFolders); var trie = new PathLookupTrie <string>(); foreach (var pid in lockFile .Libraries .Where(l => l.Type == LibraryType.Package) .Select(l => new PackageIdentity(l.Name, l.Version))) { var packageInstallPath = fppr.GetPackageDirectory(pid.Id, pid.Version); if (string.IsNullOrEmpty(packageInstallPath)) { throw new KeyNotFoundException(string.Format(CultureInfo.CurrentCulture, VsResources.PathContext_PackageDirectoryNotFound, pid)); } trie[packageInstallPath] = packageInstallPath; } return(new VsIndexedPathContext( userPackageFolder, fallbackPackageFolders, trie)); }
private static string ResolvePackageFullPath(FallbackPackagePathResolver packagePathResolver, string name, string version) { var packageFolder = packagePathResolver.GetPackageDirectory(name, version); if (packageFolder != null) { return(packageFolder); } string message = $@"The requested package ({name},{version}) was not found in the global Nuget cache(s). . Try executing/publishing the script again with the '--no-cache' option"; throw new InvalidOperationException(message); }
public PackageDescription GetDescription( NuGetFramework targetFramework, LockFileLibrary package, LockFileTargetLibrary targetLibrary) { // If a NuGet dependency is supposed to provide assemblies but there is no assembly compatible with // current target framework, we should mark this dependency as unresolved var containsAssembly = package.Files .Select(f => f.Replace('/', Path.DirectorySeparatorChar)) .Any(x => x.StartsWith($"ref{Path.DirectorySeparatorChar}") || x.StartsWith($"lib{Path.DirectorySeparatorChar}")); var compatible = targetLibrary.FrameworkAssemblies.Any() || targetLibrary.CompileTimeAssemblies.Any() || targetLibrary.RuntimeAssemblies.Any() || !containsAssembly; var dependencies = new List <ProjectLibraryDependency>(targetLibrary.Dependencies.Count + targetLibrary.FrameworkAssemblies.Count); PopulateDependencies(dependencies, targetLibrary, targetFramework); var path = _packagePathResolver?.GetPackageDirectory(package.Name, package.Version); bool exists = path != null; string hashPath = null; if (_versionFolderPathResolver != null) { hashPath = _versionFolderPathResolver.GetHashFileName(package.Name, package.Version); } if (exists) { // If the package's compile time assemblies is for a portable profile then, read the assembly metadata // and turn System.* references into reference assembly dependencies PopulateLegacyPortableDependencies(targetFramework, dependencies, path, targetLibrary); } var packageDescription = new PackageDescription( path, hashPath, package, targetLibrary, dependencies, compatible, resolved: compatible && exists); return(packageDescription); }
public async Task <bool> ExecuteInitScriptAsync(PackageIdentity identity) { var result = false; // Reserve the key. We can remove if the package has not been restored. if (TryMarkVisited(identity, PackageInitPS1State.NotFound)) { var nugetPaths = NuGetPathContext.Create(Settings); var fallbackResolver = new FallbackPackagePathResolver(nugetPaths); var installPath = fallbackResolver.GetPackageDirectory(identity.Id, identity.Version); if (!string.IsNullOrEmpty(installPath)) { var scriptPath = Path.Combine(installPath, "tools", PowerShellScripts.Init); if (File.Exists(scriptPath)) { // Init.ps1 is present and will be executed. InitScriptExecutions.TryUpdate( identity, PackageInitPS1State.FoundAndExecuted, PackageInitPS1State.NotFound); var request = new ScriptExecutionRequest(scriptPath, installPath, identity, project: null); await ExecuteScriptCoreAsync(request); result = true; } } else { // Package is not restored. Do not cache the results. PackageInitPS1State dummy; InitScriptExecutions.TryRemove(identity, out dummy); result = false; } } else { // Key is already present. Simply access its value result = (InitScriptExecutions[identity] == PackageInitPS1State.FoundAndExecuted); } return(result); }
private void ExecuteInitPs1ForBuildIntegrated( List <PackageIdentity> sortedGlobalPackages, HashSet <PackageIdentity> finishedPackages) { var nugetPaths = NuGetPathContext.Create(_settings); var fallbackResolver = new FallbackPackagePathResolver(nugetPaths); foreach (var package in sortedGlobalPackages) { if (finishedPackages.Add(package)) { // Find the package path across all folders var pathToPackage = fallbackResolver.GetPackageDirectory(package.Id, package.Version); ExecuteInitPs1(pathToPackage, package); } } }
public async Task FallbackPackagePathResolver_FindPackageInFallbackFolder_WithOnlyHashFile() { // Arrange using (var mockBaseDirectory = TestDirectory.Create()) { var userFolder = Path.Combine(mockBaseDirectory, "global"); var fallbackFolders = new List <string>() { Path.Combine(mockBaseDirectory, "fallback1"), Path.Combine(mockBaseDirectory, "fallback2"), }; Directory.CreateDirectory(userFolder); foreach (var fallback in fallbackFolders) { Directory.CreateDirectory(fallback); } var saveMode = PackageSaveMode.Nuspec | PackageSaveMode.Files; var targetFolder = fallbackFolders[0]; await SimpleTestPackageUtility.CreateFolderFeedV3Async( targetFolder, saveMode, new PackageIdentity("a", NuGetVersion.Parse("1.0.0"))); // delete .nupkg.metadata file var localResolver = new VersionFolderPathResolver(targetFolder); File.Delete(localResolver.GetNupkgMetadataPath("a", NuGetVersion.Parse("1.0.0"))); var expected = Path.Combine(targetFolder, "a", "1.0.0"); var resolver = new FallbackPackagePathResolver(userFolder, fallbackFolders); // Act var path = resolver.GetPackageDirectory("a", "1.0.0"); // Assert Assert.Equal(expected, path); } }
public void FallbackPackagePathResolver_MissingPackageNoFallbacks() { // Arrange using (var mockBaseDirectory = TestFileSystemUtility.CreateRandomTestFolder()) { var userFolder = Path.Combine(mockBaseDirectory, "global"); var fallbackFolders = new List <string>() { }; var resolver = new FallbackPackagePathResolver(userFolder, fallbackFolders); // Act var path = resolver.GetPackageDirectory("a", "1.0.0"); // Assert Assert.Null(path); } }
public async Task FallbackPackagePathResolver_FindPackageInFallbackFolder2() { // Arrange using (var mockBaseDirectory = TestFileSystemUtility.CreateRandomTestFolder()) { var userFolder = Path.Combine(mockBaseDirectory, "global"); var fallbackFolders = new List <string>() { Path.Combine(mockBaseDirectory, "fallback1"), Path.Combine(mockBaseDirectory, "fallback2"), }; Directory.CreateDirectory(userFolder); foreach (var fallback in fallbackFolders) { Directory.CreateDirectory(fallback); } var saveMode = PackageSaveMode.Nuspec | PackageSaveMode.Files; var targetFolder = fallbackFolders[1]; await SimpleTestPackageUtility.CreateFolderFeedV3( targetFolder, saveMode, new PackageIdentity("a", NuGetVersion.Parse("1.0.0"))); var expected = Path.Combine(targetFolder, "a", "1.0.0"); var resolver = new FallbackPackagePathResolver(userFolder, fallbackFolders); // Act var path = resolver.GetPackageDirectory("a", "1.0.0"); // Assert Assert.Equal(expected, path); } }
private async Task ExecuteInitPs1ForBuildIntegratedAsync( List <PackageIdentity> sortedGlobalPackages, HashSet <PackageIdentity> finishedPackages) { var nugetPaths = NuGetPathContext.Create(_settings); var fallbackResolver = new FallbackPackagePathResolver(nugetPaths); foreach (var package in sortedGlobalPackages) { if (finishedPackages.Add(package)) { // Find the package in the global packages folder or any of the fallback folders. var installPath = fallbackResolver.GetPackageDirectory(package.Id, package.Version); if (installPath == null) { continue; } await ExecuteInitPs1Async(installPath, package); } } }
public RuntimeGraph Collect(LockFile lockFile) { string userPackageFolder = lockFile.PackageFolders.FirstOrDefault()?.Path; var fallBackFolders = lockFile.PackageFolders.Skip(1).Select(f => f.Path); var packageResolver = new FallbackPackagePathResolver(userPackageFolder, fallBackFolders); var graph = RuntimeGraph.Empty; foreach (var library in lockFile.Libraries) { if (string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase)) { var runtimeJson = library.Files.FirstOrDefault(f => f == RuntimeJsonFileName); if (runtimeJson != null) { var libraryPath = packageResolver.GetPackageDirectory(library.Name, library.Version); var runtimeJsonFullName = Path.Combine(libraryPath, runtimeJson); graph = RuntimeGraph.Merge(graph, JsonRuntimeFormat.ReadRuntimeGraph(runtimeJsonFullName)); } } } return(graph); }
async Task <bool> OpenReadmeFiles( NuGetProject nuGetProject, PackageIdentity package, NuGet.ProjectManagement.ExecutionContext executionContext) { //packagesPath is different for project.json vs Packages.config scenarios. So check if the project is a build-integrated project var buildIntegratedProject = nuGetProject as BuildIntegratedNuGetProject; var readmeFilePath = String.Empty; if (buildIntegratedProject != null) { var pathContext = NuGetPathContext.Create(settings); var pathResolver = new FallbackPackagePathResolver(pathContext); string packageFolderPath = pathResolver.GetPackageDirectory(package.Id, package.Version); if (Directory.Exists(packageFolderPath)) { readmeFilePath = Path.Combine(packageFolderPath, Constants.ReadmeFileName); } } else { var packagePath = packageManager.PackagesFolderNuGetProject.GetInstalledPackageFilePath(package); if (File.Exists(packagePath)) { readmeFilePath = Path.Combine(Path.GetDirectoryName(packagePath), Constants.ReadmeFileName); } } if (File.Exists(readmeFilePath)) { await executionContext.OpenFile(readmeFilePath); return(true); } return(false); }
public string GetPackageDirectory(string packageId, NuGetVersion version) { return(_packagePathResolver.GetPackageDirectory(packageId, version)); }
public IEnumerable <IVsPackageMetadata> GetInstalledPackages(Project project) { if (project == null) { throw new ArgumentNullException("project"); } return(NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate { var packages = new List <IVsPackageMetadata>(); if (_solutionManager != null && !string.IsNullOrEmpty(_solutionManager.SolutionDirectory)) { //switch to background thread await TaskScheduler.Default; NuGetPackageManager nuGetPackageManager = CreateNuGetPackageManager(); var projectContext = new VSAPIProjectContext { PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance), NullLogger.Instance) }; var nuGetProject = await _solutionManager.GetOrCreateProjectAsync( project, projectContext); if (nuGetProject != null) { FallbackPackagePathResolver pathResolver = null; var buildIntegratedProject = nuGetProject as BuildIntegratedNuGetProject; if (buildIntegratedProject != null) { pathResolver = await GetPackagesPathResolverAsync(buildIntegratedProject); } var installedPackages = await nuGetProject.GetInstalledPackagesAsync(CancellationToken.None); foreach (var package in installedPackages) { if (!package.PackageIdentity.HasVersion) { // Currently we are not supporting floating versions // because of that we will skip this package so that it doesn't throw ArgumentNullException continue; } string installPath; if (buildIntegratedProject != null) { installPath = pathResolver.GetPackageDirectory(package.PackageIdentity.Id, package.PackageIdentity.Version); } else { // Get the install path for package installPath = nuGetPackageManager.PackagesFolderNuGetProject.GetInstalledPath( package.PackageIdentity); if (!string.IsNullOrEmpty(installPath)) { // normalize the path and take the dir if the nupkg path was given var dir = new DirectoryInfo(installPath); installPath = dir.FullName; } } var metadata = new VsPackageMetadata(package.PackageIdentity, installPath); packages.Add(metadata); } } } return packages; })); }
public IEnumerable <IVsPackageMetadata> GetInstalledPackages(Project project) { if (project == null) { throw new ArgumentNullException("project"); } return(NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate { var packages = new List <IVsPackageMetadata>(); if (_solutionManager != null && !string.IsNullOrEmpty(_solutionManager.SolutionDirectory)) { InitializePackageManagerAndPackageFolderPath(); var nuGetProject = await _solutionManager.GetOrCreateProjectAsync( project, new VSAPIProjectContext()); if (nuGetProject != null) { FallbackPackagePathResolver pathResolver = null; var buildIntegratedProject = nuGetProject as BuildIntegratedNuGetProject; if (buildIntegratedProject != null) { pathResolver = await GetPackagesPathResolverAsync(buildIntegratedProject); } var installedPackages = await nuGetProject.GetInstalledPackagesAsync(CancellationToken.None); foreach (var package in installedPackages) { string installPath; if (buildIntegratedProject != null) { installPath = pathResolver.GetPackageDirectory(package.PackageIdentity.Id, package.PackageIdentity.Version); } else { // Get the install path for package installPath = _packageManager.PackagesFolderNuGetProject.GetInstalledPath( package.PackageIdentity); if (!string.IsNullOrEmpty(installPath)) { // normalize the path and take the dir if the nupkg path was given var dir = new DirectoryInfo(installPath); installPath = dir.FullName; } } var metadata = new VsPackageMetadata(package.PackageIdentity, installPath); packages.Add(metadata); } } } return packages; })); }
public string GetPackageDirectory(string packageId, NuGetVersion version) => _packagePathResolver?.GetPackageDirectory(packageId, version);
public IEnumerable <IVsPackageMetadata> GetInstalledPackages() { try { var packages = new HashSet <IVsPackageMetadata>(new VsPackageMetadataComparer()); return(_threadingService.JoinableTaskFactory.Run(async delegate { // Calls may occur in the template wizard before the solution is actually created, // in that case return no projects if (_solutionManager != null && !string.IsNullOrEmpty(_solutionManager.SolutionDirectory)) { //switch to background thread await TaskScheduler.Default; NuGetPackageManager nuGetPackageManager = CreateNuGetPackageManager(); foreach (var project in (await _solutionManager.GetNuGetProjectsAsync())) { FallbackPackagePathResolver pathResolver = null; var buildIntegratedProject = project as BuildIntegratedNuGetProject; if (buildIntegratedProject != null) { pathResolver = await GetPackagesPathResolverAsync(buildIntegratedProject); } var installedPackages = await project.GetInstalledPackagesAsync(CancellationToken.None); foreach (var package in installedPackages) { var identity = package.PackageIdentity; if (!identity.HasVersion) { // Currently we are not supporting floating versions // because of that we will skip this package continue; } // find packages using the solution level packages folder string installPath; if (buildIntegratedProject != null) { installPath = pathResolver.GetPackageDirectory(identity.Id, identity.Version); } else { installPath = nuGetPackageManager .PackagesFolderNuGetProject .GetInstalledPath(identity); } var metadata = new VsPackageMetadata(package.PackageIdentity, installPath); packages.Add(metadata); } } } return packages; })); } catch (Exception exception) { _telemetryProvider.PostFault(exception, typeof(VsPackageInstallerServices).FullName); throw; } }