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