private async Task <(IPackageFeed?mainFeed, IPackageFeed?recommenderFeed)> CreatePackageFeedAsync(
IReadOnlyCollection <IProjectContextInfo> projectContextInfos,
IReadOnlyCollection <string> targetFrameworks,
ItemFilter itemFilter,
bool recommendPackages,
IEnumerable <SourceRepository> sourceRepositories,
CancellationToken cancellationToken)
{
var logger = new VisualStudioActivityLogger();
var uiLogger = ServiceLocator.GetInstance <INuGetUILogger>();
var packageFeeds = (mainFeed: (IPackageFeed?)null, recommenderFeed: (IPackageFeed?)null);
if (itemFilter == ItemFilter.All && recommendPackages == false)
{
packageFeeds.mainFeed = new MultiSourcePackageFeed(sourceRepositories, uiLogger, TelemetryActivity.NuGetTelemetryService);
return(packageFeeds);
}
IInstalledAndTransitivePackages installedAndTransitivePackages = await GetInstalledAndTransitivePackagesAsync(projectContextInfos, cancellationToken);
PackageCollection installedPackageCollection = PackageCollection.FromPackageReferences(installedAndTransitivePackages.InstalledPackages);
PackageCollection transitivePackageCollection = PackageCollection.FromPackageReferences(installedAndTransitivePackages.TransitivePackages);
SourceRepository packagesFolderSourceRepository = await _packagesFolderLocalRepositoryLazy.GetValueAsync(cancellationToken);
IEnumerable <SourceRepository> globalPackageFolderRepositories = await _globalPackageFolderRepositoriesLazy.GetValueAsync(cancellationToken);
var metadataProvider = new MultiSourcePackageMetadataProvider(
sourceRepositories,
packagesFolderSourceRepository,
globalPackageFolderRepositories,
logger);
if (itemFilter == ItemFilter.All)
{
// if we get here, recommendPackages == true
packageFeeds.mainFeed = new MultiSourcePackageFeed(sourceRepositories, uiLogger, TelemetryActivity.NuGetTelemetryService);
packageFeeds.recommenderFeed = new RecommenderPackageFeed(
sourceRepositories,
installedPackageCollection,
transitivePackageCollection,
targetFrameworks,
metadataProvider,
logger);
return(packageFeeds);
}
if (itemFilter == ItemFilter.Installed)
{
packageFeeds.mainFeed = new InstalledPackageFeed(installedPackageCollection, metadataProvider, logger);
return(packageFeeds);
}
if (itemFilter == ItemFilter.Consolidate)
{
packageFeeds.mainFeed = new ConsolidatePackageFeed(installedPackageCollection, metadataProvider, logger);
return(packageFeeds);
}
// Search all / updates available cannot work without a source repo
if (sourceRepositories == null)
{
return(packageFeeds);
}
if (itemFilter == ItemFilter.UpdatesAvailable)
{
packageFeeds.mainFeed = new UpdatePackageFeed(
_serviceBroker,
installedPackageCollection,
metadataProvider,
projectContextInfos.ToArray());
return(packageFeeds);
}
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture, Strings.UnsupportedFeedType, itemFilter));
}
/// <summary>
/// Get only the direct dependencies from a project
/// </summary>
public static async Task <IReadOnlyList <ProjectRestoreReference> > GetDirectProjectReferences(
EnvDTEProject project,
IEnumerable <string> resolvedProjects,
ILogger log)
{
return(await NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
// DTE calls need to be done from the main thread
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var results = new List <ProjectRestoreReference>();
var itemsFactory = ServiceLocator.GetInstance <IVsEnumHierarchyItemsFactory>();
// Verify ReferenceOutputAssembly
var excludedProjects = GetExcludedReferences(project, itemsFactory);
var hasMissingReferences = false;
// find all references in the project
foreach (var childReference in GetProjectReferences(project))
{
try
{
var reference3 = childReference as Reference3;
// check if deferred projects resolved this reference, which means this is still not loaded so simply continue
// We'll get this reference from deferred projects later
if (reference3 != null &&
resolvedProjects.Contains(reference3.Name, StringComparer.OrdinalIgnoreCase))
{
continue;
}
// Set missing reference if
// 1. reference is null OR
// 2. reference is not resolved which means project is not loaded or assembly not found.
else if (reference3 == null || !reference3.Resolved)
{
// Skip missing references and show a warning
hasMissingReferences = true;
continue;
}
// Skip missing references
if (childReference.SourceProject != null)
{
if (EnvDTEProjectUtility.HasUnsupportedProjectCapability(childReference.SourceProject))
{
// Skip this shared project
continue;
}
var childProjectPath = EnvDTEProjectUtility.GetFullProjectPath(childReference.SourceProject);
// Skip projects which have ReferenceOutputAssembly=false
if (!string.IsNullOrEmpty(childProjectPath) &&
!excludedProjects.Contains(childProjectPath, StringComparer.OrdinalIgnoreCase))
{
var restoreReference = new ProjectRestoreReference()
{
ProjectPath = childProjectPath,
ProjectUniqueName = childProjectPath
};
results.Add(restoreReference);
}
}
}
catch (Exception ex)
{
// Exceptions are expected in some scenarios for native projects,
// ignore them and show a warning
hasMissingReferences = true;
log.LogDebug(ex.ToString());
Debug.Fail("Unable to find project dependencies: " + ex.ToString());
}
}
if (hasMissingReferences)
{
// Log a generic message once per project if any items could not be resolved.
// In most cases this can be ignored, but in the rare case where the unresolved
// item is actually a project the restore result will be incomplete.
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.UnresolvedItemDuringProjectClosureWalk,
EnvDTEProjectUtility.GetUniqueName(project));
log.LogVerbose(message);
}
return results;
}));
}
/// <summary>
/// Gets the VsSettings singleton object.
/// </summary>
/// <returns>The VsSettings object in the system.</returns>
public static ISettings GetVsSettings()
{
return(ServiceLocator.GetComponentModelService <ISettings>());
}
public async ValueTask <IReadOnlyList <ProjectAction> > GetUpdateActionsAsync(
IReadOnlyCollection <string> projectIds,
IReadOnlyCollection <PackageIdentity> packageIdentities,
VersionConstraints versionConstraints,
bool includePrelease,
DependencyBehavior dependencyBehavior,
IReadOnlyList <string> packageSourceNames,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectIds);
Assumes.NotNullOrEmpty(packageIdentities);
Assumes.NotNullOrEmpty(packageSourceNames);
Assumes.NotNull(_state.SourceCacheContext);
Assumes.NotNull(_state.ResolvedActions);
Assumes.Null(_state.PackageIdentity);
var primarySources = new List <SourceRepository>();
var secondarySources = new List <SourceRepository>();
ISourceRepositoryProvider sourceRepositoryProvider = await _sharedState.SourceRepositoryProvider.GetValueAsync(cancellationToken);
IEnumerable <SourceRepository> sourceRepositories = sourceRepositoryProvider.GetRepositories();
var packageSourceNamesSet = new HashSet <string>(packageSourceNames, StringComparer.OrdinalIgnoreCase);
foreach (SourceRepository sourceRepository in sourceRepositories)
{
if (packageSourceNamesSet.Contains(sourceRepository.PackageSource.Name))
{
primarySources.Add(sourceRepository);
}
if (sourceRepository.PackageSource.IsEnabled)
{
secondarySources.Add(sourceRepository);
}
}
INuGetProjectContext projectContext = await ServiceLocator.GetInstanceAsync <INuGetProjectContext>();
var projects = new List <NuGetProject>();
foreach (string projectId in projectIds)
{
(bool success, NuGetProject? project) = await TryGetNuGetProjectMatchingProjectIdAsync(projectId);
Assumes.True(success);
Assumes.NotNull(project);
projects.Add(project);
}
var resolutionContext = new ResolutionContext(
dependencyBehavior,
includePrelease,
includeUnlisted: true,
versionConstraints,
new GatherCache(),
_state.SourceCacheContext);
NuGetPackageManager packageManager = await _sharedState.PackageManager.GetValueAsync(cancellationToken);
IEnumerable <NuGetProjectAction> actions = await packageManager.PreviewUpdatePackagesAsync(
packageIdentities.ToList(),
projects,
resolutionContext,
projectContext,
primarySources,
secondarySources,
cancellationToken);
var projectActions = new List <ProjectAction>();
foreach (NuGetProjectAction action in actions)
{
string projectId = action.Project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId);
var resolvedAction = new ResolvedAction(action.Project, action);
var projectAction = new ProjectAction(
CreateProjectActionId(),
projectId,
action.PackageIdentity,
action.NuGetProjectActionType,
implicitActions: null);
_state.ResolvedActions[projectAction.Id] = resolvedAction;
projectActions.Add(projectAction);
}
return(projectActions);
}
public async ValueTask <IReadOnlyList <ProjectAction> > GetInstallActionsAsync(
IReadOnlyCollection <string> projectIds,
PackageIdentity packageIdentity,
VersionConstraints versionConstraints,
bool includePrelease,
DependencyBehavior dependencyBehavior,
IReadOnlyList <string> packageSourceNames,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectIds);
Assumes.NotNull(packageIdentity);
Assumes.NotNullOrEmpty(packageSourceNames);
Assumes.Null(_state.PackageIdentity);
Assumes.True(_state.ResolvedActions.Count == 0);
Assumes.NotNull(_state.SourceCacheContext);
cancellationToken.ThrowIfCancellationRequested();
_state.PackageIdentity = packageIdentity;
IReadOnlyList <SourceRepository> sourceRepositories = await GetSourceRepositoriesAsync(
packageSourceNames,
cancellationToken);
Assumes.NotNullOrEmpty(sourceRepositories);
INuGetProjectContext projectContext = await ServiceLocator.GetInstanceAsync <INuGetProjectContext>();
IReadOnlyList <NuGetProject> projects = await GetProjectsAsync(projectIds, cancellationToken);
var resolutionContext = new ResolutionContext(
dependencyBehavior,
includePrelease,
includeUnlisted: false,
versionConstraints,
new GatherCache(),
_state.SourceCacheContext);
NuGetPackageManager packageManager = await _sharedState.PackageManager.GetValueAsync(cancellationToken);
IEnumerable <ResolvedAction> resolvedActions = await packageManager.PreviewProjectsInstallPackageAsync(
projects,
_state.PackageIdentity,
resolutionContext,
projectContext,
sourceRepositories,
cancellationToken);
var projectActions = new List <ProjectAction>();
foreach (ResolvedAction resolvedAction in resolvedActions)
{
List <ImplicitProjectAction>?implicitActions = null;
if (resolvedAction.Action is BuildIntegratedProjectAction buildIntegratedAction)
{
implicitActions = new List <ImplicitProjectAction>();
foreach (NuGetProjectAction?buildAction in buildIntegratedAction.GetProjectActions())
{
var implicitAction = new ImplicitProjectAction(
CreateProjectActionId(),
buildAction.PackageIdentity,
buildAction.NuGetProjectActionType);
implicitActions.Add(implicitAction);
}
}
string projectId = resolvedAction.Project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId);
var projectAction = new ProjectAction(
CreateProjectActionId(),
projectId,
resolvedAction.Action.PackageIdentity,
resolvedAction.Action.NuGetProjectActionType,
implicitActions);
_state.ResolvedActions[projectAction.Id] = resolvedAction;
projectActions.Add(projectAction);
}
return(projectActions);
}
public async ValueTask <IReadOnlyList <ProjectAction> > GetUpdateActionsAsync(
IReadOnlyCollection <string> projectIds,
IReadOnlyCollection <PackageIdentity> packageIdentities,
VersionConstraints versionConstraints,
bool includePrelease,
DependencyBehavior dependencyBehavior,
IReadOnlyList <string> packageSourceNames,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectIds);
Assumes.NotNullOrEmpty(packageIdentities);
Assumes.NotNullOrEmpty(packageSourceNames);
Assumes.NotNull(_state.SourceCacheContext);
Assumes.NotNull(_state.ResolvedActions);
Assumes.Null(_state.PackageIdentity);
return(await CatchAndRethrowExceptionAsync(async() =>
{
var primarySources = new List <SourceRepository>();
var secondarySources = new List <SourceRepository>();
IEnumerable <SourceRepository> sourceRepositories = _sharedState.SourceRepositoryProvider.GetRepositories();
var packageSourceNamesSet = new HashSet <string>(packageSourceNames, StringComparer.OrdinalIgnoreCase);
foreach (SourceRepository sourceRepository in sourceRepositories)
{
if (packageSourceNamesSet.Contains(sourceRepository.PackageSource.Name))
{
primarySources.Add(sourceRepository);
}
if (sourceRepository.PackageSource.IsEnabled)
{
secondarySources.Add(sourceRepository);
}
}
INuGetProjectContext projectContext = await ServiceLocator.GetComponentModelServiceAsync <INuGetProjectContext>();
IReadOnlyList <NuGetProject> projects = await GetProjectsAsync(projectIds, cancellationToken);
var resolutionContext = new ResolutionContext(
dependencyBehavior,
includePrelease,
includeUnlisted: true,
versionConstraints,
new GatherCache(),
_state.SourceCacheContext);
NuGetPackageManager packageManager = await _sharedState.GetPackageManagerAsync(cancellationToken);
IEnumerable <NuGetProjectAction> actions = await packageManager.PreviewUpdatePackagesAsync(
packageIdentities.ToList(),
projects,
resolutionContext,
projectContext,
primarySources,
secondarySources,
cancellationToken);
var projectActions = new List <ProjectAction>();
foreach (NuGetProjectAction action in actions)
{
var resolvedAction = new ResolvedAction(action.Project, action);
ProjectAction projectAction = CreateProjectAction(resolvedAction);
_state.ResolvedActions[projectAction.Id] = resolvedAction;
projectActions.Add(projectAction);
}
return projectActions;
}));
}
public async ValueTask <IReadOnlyList <ProjectAction> > GetInstallActionsAsync(
IReadOnlyCollection <string> projectIds,
PackageIdentity packageIdentity,
VersionConstraints versionConstraints,
bool includePrerelease,
DependencyBehavior dependencyBehavior,
IReadOnlyList <string> packageSourceNames,
VersionRange?versionRange,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectIds);
Assumes.NotNull(packageIdentity);
Assumes.NotNullOrEmpty(packageSourceNames);
Assumes.Null(_state.PackageIdentity);
Assumes.True(_state.ResolvedActions.Count == 0);
Assumes.NotNull(_state.SourceCacheContext);
cancellationToken.ThrowIfCancellationRequested();
return(await CatchAndRethrowExceptionAsync(async() =>
{
_state.PackageIdentity = packageIdentity;
IReadOnlyList <SourceRepository> sourceRepositories = GetSourceRepositories(
packageSourceNames,
cancellationToken);
Assumes.NotNullOrEmpty(sourceRepositories);
INuGetProjectContext projectContext = await ServiceLocator.GetComponentModelServiceAsync <INuGetProjectContext>();
IReadOnlyList <NuGetProject> projects = await GetProjectsAsync(projectIds, cancellationToken);
var resolutionContext = new ResolutionContext(
dependencyBehavior,
includePrerelease,
includeUnlisted: false,
versionConstraints,
new GatherCache(),
_state.SourceCacheContext);
NuGetPackageManager packageManager = await _sharedState.GetPackageManagerAsync(cancellationToken);
IEnumerable <ResolvedAction> resolvedActions = await packageManager.PreviewProjectsInstallPackageAsync(
projects,
_state.PackageIdentity,
resolutionContext,
projectContext,
sourceRepositories,
versionRange,
cancellationToken);
var projectActions = new List <ProjectAction>();
foreach (ResolvedAction resolvedAction in resolvedActions)
{
ProjectAction projectAction = CreateProjectAction(resolvedAction);
_state.ResolvedActions[projectAction.Id] = resolvedAction;
projectActions.Add(projectAction);
}
return projectActions;
}));
}
/// <summary>
/// Gets the VsSettings singleton object.
/// </summary>
/// <returns>The VsSettings object in the system.</returns>
public static Configuration.ISettings GetVsSettings()
{
return(ServiceLocator.GetInstance <Configuration.ISettings>());
}
