protected NuGetPowerShellBaseCommand()
{
var componentModel = NuGetUIThreadHelper.JoinableTaskFactory.Run(ServiceLocator.GetComponentModelAsync);
_sourceRepositoryProvider = componentModel.GetService <ISourceRepositoryProvider>();
ConfigSettings = componentModel.GetService <ISettings>();
VsSolutionManager = componentModel.GetService <IVsSolutionManager>();
SourceControlManagerProvider = componentModel.GetService <ISourceControlManagerProvider>();
_commonOperations = componentModel.GetService <ICommonOperations>();
PackageRestoreManager = componentModel.GetService <IPackageRestoreManager>();
_deleteOnRestartManager = componentModel.GetService <IDeleteOnRestartManager>();
_nuGetProgressReporter = componentModel.GetService <IRestoreProgressReporter>();
DTE = ServiceLocator.GetInstance <DTE>();
var logger = new LoggerAdapter(this);
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(ConfigSettings, logger),
logger);
if (_commonOperations != null)
{
ExecutionContext = new IDEExecutionContext(_commonOperations);
}
ActivityCorrelationId.StartNew();
}
public static async Task <NuGetUI> CreateAsync(
IServiceBroker serviceBroker,
ICommonOperations commonOperations,
NuGetUIProjectContext projectContext,
ISourceRepositoryProvider sourceRepositoryProvider,
ISettings settings,
IVsSolutionManager solutionManager,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IUserSettingsManager userSettingsManager,
IDeleteOnRestartManager deleteOnRestartManager,
SolutionUserOptions solutionUserOptions,
INuGetLockService lockService,
INuGetUILogger logger,
IRestoreProgressReporter restoreProgressReporter,
CancellationToken cancellationToken,
params IProjectContextInfo[] projects)
{
Assumes.NotNull(serviceBroker);
Assumes.NotNull(commonOperations);
Assumes.NotNull(projectContext);
Assumes.NotNull(sourceRepositoryProvider);
Assumes.NotNull(settings);
Assumes.NotNull(solutionManager);
Assumes.NotNull(packageRestoreManager);
Assumes.NotNull(optionsPageActivator);
Assumes.NotNull(userSettingsManager);
Assumes.NotNull(deleteOnRestartManager);
Assumes.NotNull(solutionUserOptions);
Assumes.NotNull(lockService);
Assumes.NotNull(restoreProgressReporter);
Assumes.NotNull(logger);
cancellationToken.ThrowIfCancellationRequested();
var nuGetUi = new NuGetUI(
commonOperations,
projectContext,
logger)
{
UIContext = await NuGetUIContext.CreateAsync(
serviceBroker,
sourceRepositoryProvider,
settings,
solutionManager,
packageRestoreManager,
optionsPageActivator,
solutionUserOptions,
deleteOnRestartManager,
lockService,
restoreProgressReporter,
cancellationToken)
};
nuGetUi.UIContext.Projects = projects;
return(nuGetUi);
}
/// <summary>
/// Restore a solution and cache the dg spec to context.
/// </summary>
public static async Task <IReadOnlyList <RestoreSummary> > RestoreAsync(
DependencyGraphSpec dgSpec,
DependencyGraphCacheContext context,
RestoreCommandProvidersCache providerCache,
Action <SourceCacheContext> cacheContextModifier,
IEnumerable <SourceRepository> sources,
Guid parentId,
bool forceRestore,
bool isRestoreOriginalAction,
IReadOnlyList <IAssetsLogMessage> additionalMessages,
IRestoreProgressReporter progressReporter,
ILogger log,
CancellationToken token)
{
// Check if there are actual projects to restore before running.
if (dgSpec.Restore.Count > 0)
{
using (var sourceCacheContext = new SourceCacheContext())
{
// Update cache context
cacheContextModifier(sourceCacheContext);
var restoreContext = GetRestoreArgs(
context,
providerCache,
sourceCacheContext,
sources,
dgSpec,
parentId,
forceRestore,
isRestoreOriginalAction,
restoreForceEvaluate: false,
additionalMessages,
progressReporter: progressReporter);
var restoreSummaries = await RestoreRunner.RunAsync(restoreContext, token);
RestoreSummary.Log(log, restoreSummaries);
await PersistDGSpec(dgSpec);
return(restoreSummaries);
}
}
return(new List <RestoreSummary>());
}
public async ValueTask <NuGetPackageManager> GetPackageManagerAsync(CancellationToken cancellationToken)
{
IDeleteOnRestartManager deleteOnRestartManager = await ServiceLocator.GetComponentModelServiceAsync <IDeleteOnRestartManager>();
ISettings settings = await ServiceLocator.GetComponentModelServiceAsync <ISettings>();
IVsSolutionManager solutionManager = await SolutionManager.GetValueAsync(cancellationToken);
IRestoreProgressReporter restoreProgressReporter = await ServiceLocator.GetComponentModelServiceAsync <IRestoreProgressReporter>();
return(new NuGetPackageManager(
SourceRepositoryProvider,
settings,
solutionManager,
deleteOnRestartManager,
restoreProgressReporter));
}
public VsPackageUninstaller(
ISourceRepositoryProvider sourceRepositoryProvider,
Configuration.ISettings settings,
IVsSolutionManager solutionManager,
IDeleteOnRestartManager deleteOnRestartManager,
INuGetTelemetryProvider telemetryProvider,
IRestoreProgressReporter restoreProgressReporter)
{
_sourceRepositoryProvider = sourceRepositoryProvider;
_settings = settings;
_solutionManager = solutionManager;
_telemetryProvider = telemetryProvider;
PumpingJTF = new PumpingJTF(NuGetUIThreadHelper.JoinableTaskFactory);
_deleteOnRestartManager = deleteOnRestartManager;
_restoreProgressReporter = restoreProgressReporter;
}
public VsPackageInstallerServices(
IVsSolutionManager solutionManager,
ISourceRepositoryProvider sourceRepositoryProvider,
ISettings settings,
IDeleteOnRestartManager deleteOnRestartManager,
IVsProjectThreadingService threadingService,
INuGetTelemetryProvider telemetryProvider,
IRestoreProgressReporter restoreProgressReporter)
{
_solutionManager = solutionManager;
_sourceRepositoryProvider = sourceRepositoryProvider;
_deleteOnRestartManager = deleteOnRestartManager;
_settings = settings;
_threadingService = threadingService;
_telemetryProvider = telemetryProvider;
_restoreProgressReporter = restoreProgressReporter;
}
/// <summary>
/// Create a restore args.
/// </summary>
private static RestoreArgs GetRestoreArgs(
DependencyGraphCacheContext context,
RestoreCommandProvidersCache providerCache,
SourceCacheContext sourceCacheContext,
IEnumerable <SourceRepository> sources,
DependencyGraphSpec dgFile,
Guid parentId,
bool forceRestore,
bool isRestoreOriginalAction,
bool restoreForceEvaluate,
IReadOnlyList <IAssetsLogMessage> additionalMessasges,
IRestoreProgressReporter progressReporter)
{
#pragma warning disable CS0618 // Type or member is obsolete
var caching = new CachingSourceProvider(new PackageSourceProvider(context.Settings, enablePackageSourcesChangedEvent: false));
#pragma warning restore CS0618 // Type or member is obsolete
foreach (var source in sources)
{
caching.AddSourceRepository(source);
}
var dgProvider = new DependencyGraphSpecRequestProvider(providerCache, dgFile);
var restoreContext = new RestoreArgs()
{
CacheContext = sourceCacheContext,
PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>()
{
dgProvider
},
Log = context.Logger,
AllowNoOp = !forceRestore,
CachingSourceProvider = caching,
ParentId = parentId,
IsRestoreOriginalAction = isRestoreOriginalAction,
RestoreForceEvaluate = restoreForceEvaluate,
AdditionalMessages = additionalMessasges,
ProgressReporter = progressReporter,
};
return(restoreContext);
}
private static async Task <RestoreSummary> ExecuteAndCommitAsync(RestoreSummaryRequest summaryRequest, IRestoreProgressReporter progressReporter, CancellationToken token)
{
RestoreResultPair result = await ExecuteAsync(summaryRequest, token);
bool isNoOp = result.Result is NoOpRestoreResult;
IReadOnlyList <string> filesToBeUpdated = isNoOp ? null : GetFilesToBeUpdated(result);
RestoreSummary summary = null;
try
{
if (!isNoOp)
{
progressReporter?.StartProjectUpdate(summaryRequest.Request.Project.FilePath, filesToBeUpdated);
}
summary = await CommitAsync(result, token);
}
finally
{
if (!isNoOp)
{
progressReporter?.EndProjectUpdate(summaryRequest.Request.Project.FilePath, filesToBeUpdated);
}
}
return(summary);
public static async ValueTask <NuGetUIContext> CreateAsync(
IServiceBroker serviceBroker,
ISourceRepositoryProvider sourceRepositoryProvider,
ISettings settings,
IVsSolutionManager solutionManager,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IUserSettingsManager userSettingsManager,
IDeleteOnRestartManager deleteOnRestartManager,
INuGetLockService lockService,
IRestoreProgressReporter restoreProgressReporter,
CancellationToken cancellationToken)
{
Assumes.NotNull(serviceBroker);
Assumes.NotNull(sourceRepositoryProvider);
Assumes.NotNull(settings);
Assumes.NotNull(solutionManager);
Assumes.NotNull(packageRestoreManager);
Assumes.NotNull(optionsPageActivator);
Assumes.NotNull(userSettingsManager);
Assumes.NotNull(deleteOnRestartManager);
Assumes.NotNull(lockService);
Assumes.NotNull(restoreProgressReporter);
cancellationToken.ThrowIfCancellationRequested();
var solutionManagerServiceWrapper = new NuGetSolutionManagerServiceWrapper();
INuGetSolutionManagerService solutionManagerService = await GetSolutionManagerServiceAsync(serviceBroker, cancellationToken);
// The initial Swap(...) should return a null implementation of the interface that does not require disposal.
// However, there's no harm in following form.
using (solutionManagerServiceWrapper.Swap(solutionManagerService))
{
}
var sourceServiceWrapper = new NuGetSourcesServiceWrapper();
INuGetSourcesService sourceService = await GetSourceServiceAsync(serviceBroker, cancellationToken);
using (sourceServiceWrapper.Swap(sourceService))
{
}
#pragma warning disable CA2000 // Dispose objects before losing scope - NuGetUIContext owns the instance and should dispose it.
var searchService = await NuGetSearchServiceReconnector.CreateAsync(serviceBroker, NuGetUIThreadHelper.JoinableTaskFactory, cancellationToken);
#pragma warning restore CA2000 // Dispose objects before losing scope
var packageManager = new NuGetPackageManager(
sourceRepositoryProvider,
settings,
solutionManager,
deleteOnRestartManager,
restoreProgressReporter);
var actionEngine = new UIActionEngine(
sourceRepositoryProvider,
packageManager,
lockService);
return(new NuGetUIContext(
serviceBroker,
searchService.Object,
solutionManager,
solutionManagerServiceWrapper,
packageManager,
actionEngine,
packageRestoreManager,
optionsPageActivator,
userSettingsManager,
sourceServiceWrapper));
}
