private VsPackageRestorer CreateTarget(
ISettings settings = null,
ISolutionManager solutionManager = null,
IPackageRestoreManager restoreManager = null,
IVsProjectThreadingService threadingService = null,
INuGetTelemetryProvider telemetryProvider = null)
{
if (settings == null)
{
settings = new Mock <ISettings>().Object;
}
if (solutionManager == null)
{
solutionManager = new Mock <ISolutionManager>().Object;
}
if (restoreManager == null)
{
restoreManager = new Mock <IPackageRestoreManager>().Object;
}
if (threadingService == null)
{
threadingService = new TestProjectThreadingService();
}
if (telemetryProvider == null)
{
// Use strict mode, as known/expected errors should not post faults.
telemetryProvider = new Mock <INuGetTelemetryProvider>(MockBehavior.Strict).Object;
}
return(new VsPackageRestorer(settings, solutionManager, restoreManager, threadingService, telemetryProvider));
}
public VsPathContextProvider(
IAsyncServiceProvider asyncServiceProvider,
Lazy <ISettings> settings,
Lazy <IVsSolutionManager> solutionManager,
Lazy <ILogger> logger,
Lazy <IMachineWideSettings> machineWideSettings,
INuGetTelemetryProvider telemetryProvider)
{
_asyncServiceprovider = asyncServiceProvider ?? throw new ArgumentNullException(nameof(asyncServiceProvider));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
_solutionManager = solutionManager ?? throw new ArgumentNullException(nameof(solutionManager));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_getLockFileOrNullAsync = BuildIntegratedProjectUtility.GetLockFileOrNull;
if (machineWideSettings == null)
{
throw new ArgumentNullException(nameof(machineWideSettings));
}
_projectContext = new Lazy <INuGetProjectContext>(() => new VSAPIProjectContext
{
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings.Value, NullLogger.Instance),
NullLogger.Instance)
});
_userWideSettings = new Microsoft.VisualStudio.Threading.AsyncLazy <ISettings>(() => Task.FromResult(Settings.LoadDefaultSettings(null, null, machineWideSettings.Value)), NuGetUIThreadHelper.JoinableTaskFactory);
_telemetryProvider = telemetryProvider ?? throw new ArgumentNullException(nameof(telemetryProvider));
}
public VsSemanticVersionComparer(INuGetTelemetryProvider telemetryProvider)
{
// MEF components do not participate in Visual Studio's Package extensibility,
// hence importing INuGetTelemetryProvider ensures that the ETW collector is
// set up correctly.
_ = telemetryProvider;
}
public VsPathContext(string userPackageFolder, IEnumerable <string> fallbackPackageFolders, INuGetTelemetryProvider telemetryProvider)
{
if (userPackageFolder == null)
{
throw new ArgumentNullException(nameof(userPackageFolder));
}
if (fallbackPackageFolders == null)
{
throw new ArgumentNullException(nameof(fallbackPackageFolders));
}
_telemetryProvider = telemetryProvider ?? throw new ArgumentNullException(nameof(telemetryProvider));
try
{
_userPackageFolder = userPackageFolder;
_fallbackPackageFolders = fallbackPackageFolders.ToList();
}
catch (Exception exception)
{
_telemetryProvider.PostFault(exception, typeof(VsPathContext).FullName);
throw;
}
}
public NuGetPackageFileService(IServiceBroker serviceBroker, INuGetTelemetryProvider nuGetTelemetryProvider)
{
_serviceBroker = serviceBroker;
Assumes.NotNull(_serviceBroker);
_nuGetTelemetryProvider = nuGetTelemetryProvider;
Assumes.NotNull(_nuGetTelemetryProvider);
}
public VsSolutionRestoreStatusProvider(
Lazy <ISolutionRestoreWorker> restoreWorker,
Lazy <IVsSolutionManager> solutionManager,
INuGetTelemetryProvider telemetryProvider)
{
_restoreWorker = restoreWorker;
_solutionManager = solutionManager;
_telemetryProvider = telemetryProvider;
}
public VsPackageInstallerProjectEvents(IPackageProjectEventsProvider eventProvider, INuGetTelemetryProvider telemetryProvider)
{
var eventSource = eventProvider.GetPackageProjectEvents();
eventSource.BatchStart += NotifyBatchStart;
eventSource.BatchEnd += NotifyBatchEnd;
// MEF components do not participate in Visual Studio's Package extensibility,
// hence importing INuGetTelemetryProvider ensures that the ETW collector is
// set up correctly.
_ = telemetryProvider;
}
public VsPackageSourceProvider(ISourceRepositoryProvider sourceRepositoryProvider, INuGetTelemetryProvider telemetryProvider)
{
if (sourceRepositoryProvider == null)
{
throw new ArgumentNullException(nameof(sourceRepositoryProvider));
}
_packageSourceProvider = sourceRepositoryProvider.PackageSourceProvider;
_telemetryProvider = telemetryProvider;
_packageSourceProvider.PackageSourcesChanged += PackageSourcesChanged;
}
public VsProjectJsonToPackageReferenceMigrator(
Lazy <IVsSolutionManager> solutionManager,
Lazy <NuGetProjectFactory> projectFactory,
INuGetTelemetryProvider telemetryProvider)
{
Assumes.Present(solutionManager);
Assumes.Present(projectFactory);
Assumes.Present(telemetryProvider);
_solutionManager = solutionManager;
_projectFactory = projectFactory;
_telemetryProvider = telemetryProvider;
}
public VsPackageRestorer(
Configuration.ISettings settings,
ISolutionManager solutionManager,
IPackageRestoreManager restoreManager,
IVsProjectThreadingService threadingService,
INuGetTelemetryProvider telemetryProvider)
{
_settings = settings;
_solutionManager = solutionManager;
_restoreManager = restoreManager;
_threadingService = threadingService;
_telemetryProvider = telemetryProvider;
}
public NuGetPackageFileService(
ServiceActivationOptions options,
IServiceBroker serviceBroker,
AuthorizationServiceClient authorizationServiceClient,
INuGetTelemetryProvider nuGetTelemetryProvider)
{
_options = options;
_serviceBroker = serviceBroker;
_authorizationServiceClient = authorizationServiceClient;
_nuGetTelemetryProvider = nuGetTelemetryProvider;
Assumes.NotNull(_serviceBroker);
Assumes.NotNull(_authorizationServiceClient);
Assumes.NotNull(_nuGetTelemetryProvider);
}
public VsRestoreProgressEvents(IPackageProjectEventsProvider eventProvider, INuGetTelemetryProvider telemetryProvider)
{
_ = eventProvider ?? throw new ArgumentNullException(nameof(eventProvider));
// MEF components do not participate in Visual Studio's Package extensibility,
// hence importing INuGetTelemetryProvider ensures that the ETW collector is
// set up correctly.
_ = telemetryProvider ?? throw new ArgumentNullException(nameof(telemetryProvider));
var eventSource = eventProvider.GetPackageProjectEvents();
eventSource.BatchStart += NotifyBatchStart;
eventSource.BatchEnd += NotifyBatchEnd;
}
public VsPackageUninstaller(
ISourceRepositoryProvider sourceRepositoryProvider,
Configuration.ISettings settings,
IVsSolutionManager solutionManager,
IDeleteOnRestartManager deleteOnRestartManager,
INuGetTelemetryProvider telemetryProvider)
{
_sourceRepositoryProvider = sourceRepositoryProvider;
_settings = settings;
_solutionManager = solutionManager;
_telemetryProvider = telemetryProvider;
PumpingJTF = new PumpingJTF(NuGetUIThreadHelper.JoinableTaskFactory);
_deleteOnRestartManager = deleteOnRestartManager;
}
public VsPathContextProvider(
Lazy <ISettings> settings,
Lazy <IVsSolutionManager> solutionManager,
[Import("VisualStudioActivityLogger")]
Lazy <ILogger> logger,
Lazy <IMachineWideSettings> machineWideSettings,
INuGetTelemetryProvider telemetryProvider)
: this(AsyncServiceProvider.GlobalProvider,
settings,
solutionManager,
logger,
machineWideSettings,
telemetryProvider)
{
}
public VsPackageInstallerServices(
IVsSolutionManager solutionManager,
ISourceRepositoryProvider sourceRepositoryProvider,
ISettings settings,
IDeleteOnRestartManager deleteOnRestartManager,
IVsProjectThreadingService threadingService,
INuGetTelemetryProvider telemetryProvider)
{
_solutionManager = solutionManager;
_sourceRepositoryProvider = sourceRepositoryProvider;
_deleteOnRestartManager = deleteOnRestartManager;
_settings = settings;
_threadingService = threadingService;
_telemetryProvider = telemetryProvider;
}
public VsIndexedPathContext(
string userPackageFolder,
IEnumerable <string> fallbackPackageFolders,
PathLookupTrie <string> index,
INuGetTelemetryProvider telemetryProvider)
{
if (index == null)
{
throw new ArgumentNullException(nameof(index));
}
UserPackageFolder = userPackageFolder ?? throw new ArgumentNullException(nameof(userPackageFolder));
FallbackPackageFolders = fallbackPackageFolders?.ToList() ?? throw new ArgumentNullException(nameof(fallbackPackageFolders));
_referenceLookupIndex = index ?? throw new ArgumentNullException(nameof(index));
_telemetryProvider = telemetryProvider ?? throw new ArgumentNullException(nameof(telemetryProvider));
}
private async ValueTask <object> CreateNuGetProjectServiceV1(
ServiceMoniker moniker,
ServiceActivationOptions options,
IServiceBroker serviceBroker,
CancellationToken cancellationToken)
{
await _lazyInitializer.InitializeAsync(cancellationToken);
IVsSolutionManager solutionManager = await _lazySolutionManager.GetValueAsync(cancellationToken);
ISettings settings = await _lazySettings.GetValueAsync(cancellationToken);
INuGetTelemetryProvider telemetryProvider = await _lazyTelemetryProvider.GetValueAsync(cancellationToken);
return(new NuGetProjectService(solutionManager, settings, telemetryProvider));
}
public VsPackageInstallerEvents(IPackageEventsProvider eventProvider, INuGetTelemetryProvider telemetryProvider)
{
_eventSource = eventProvider.GetPackageEvents();
_eventSource.PackageInstalled += Source_PackageInstalled;
_eventSource.PackageInstalling += Source_PackageInstalling;
_eventSource.PackageReferenceAdded += Source_PackageReferenceAdded;
_eventSource.PackageReferenceRemoved += Source_PackageReferenceRemoved;
_eventSource.PackageUninstalled += Source_PackageUninstalled;
_eventSource.PackageUninstalling += Source_PackageUninstalling;
// MEF components do not participate in Visual Studio's Package extensibility,
// hence importing INuGetTelemetryProvider ensures that the ETW collector is
// set up correctly.
_ = telemetryProvider;
}
public VsPackageInstaller(
ISourceRepositoryProvider sourceRepositoryProvider,
ISettings settings,
IVsSolutionManager solutionManager,
IDeleteOnRestartManager deleteOnRestartManager,
INuGetTelemetryProvider telemetryProvider,
IRestoreProgressReporter restoreProgressReporter)
{
_sourceRepositoryProvider = sourceRepositoryProvider;
_settings = settings;
_solutionManager = solutionManager;
_deleteOnRestartManager = deleteOnRestartManager;
_telemetryProvider = telemetryProvider;
_restoreProgressReporter = restoreProgressReporter;
PumpingJTF = new PumpingJTF(NuGetUIThreadHelper.JoinableTaskFactory);
}
private VsPackageSourceProvider CreateTarget(
ISourceRepositoryProvider sourceRepositoryProvider = null,
INuGetTelemetryProvider telemetryProvider = null)
{
if (sourceRepositoryProvider == null)
{
sourceRepositoryProvider = new Mock <ISourceRepositoryProvider>().Object;
}
if (telemetryProvider == null)
{
// Use strict mode, as known/expected exceptions should not be logged as faults
telemetryProvider = new Mock <INuGetTelemetryProvider>(MockBehavior.Strict).Object;
}
return(new VsPackageSourceProvider(sourceRepositoryProvider, telemetryProvider));
}
/// <summary>
/// This constructor is just used for testing.
/// </summary>
public VsPathContextProvider(
ISettings settings,
IVsSolutionManager solutionManager,
ILogger logger,
Func <BuildIntegratedNuGetProject, Task <LockFile> > getLockFileOrNullAsync,
INuGetTelemetryProvider telemetryProvider)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (solutionManager == null)
{
throw new ArgumentNullException(nameof(solutionManager));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_settings = new Lazy <ISettings>(() => settings);
_solutionManager = new Lazy <IVsSolutionManager>(() => solutionManager);
_logger = new Lazy <ILogger>(() => logger);
_getLockFileOrNullAsync = getLockFileOrNullAsync ?? BuildIntegratedProjectUtility.GetLockFileOrNull;
_projectContext = new Lazy <INuGetProjectContext>(() =>
{
return(new VSAPIProjectContext
{
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings.Value, NullLogger.Instance),
NullLogger.Instance)
});
});
_telemetryProvider = telemetryProvider ?? throw new ArgumentNullException(nameof(telemetryProvider));
}
private VsPackageInstallerServices CreateTarget(
IVsSolutionManager vsSolutionManager = null,
ISourceRepositoryProvider sourceRepositoryProvider = null,
ISettings settings = null,
IDeleteOnRestartManager deleteOnRestartManager = null,
IVsProjectThreadingService vsProjectThreadingService = null,
INuGetTelemetryProvider telemetryProvider = null)
{
if (vsSolutionManager == null)
{
vsSolutionManager = new Mock <IVsSolutionManager>().Object;
}
if (sourceRepositoryProvider == null)
{
sourceRepositoryProvider = new Mock <ISourceRepositoryProvider>().Object;
}
if (settings == null)
{
settings = new Mock <ISettings>().Object;
}
if (deleteOnRestartManager == null)
{
deleteOnRestartManager = new Mock <IDeleteOnRestartManager>().Object;
}
if (vsProjectThreadingService == null)
{
vsProjectThreadingService = new TestProjectThreadingService();
}
if (telemetryProvider == null)
{
// Expected/user input errors should not be recorded as faults, hence use strict mode
telemetryProvider = new Mock <INuGetTelemetryProvider>(MockBehavior.Strict).Object;
}
return(new VsPackageInstallerServices(vsSolutionManager, sourceRepositoryProvider, settings, deleteOnRestartManager, vsProjectThreadingService, telemetryProvider));
}
public VsPathContext(NuGetPathContext pathContext, INuGetTelemetryProvider telemetryProvider, string solutionPackageFolder = null)
{
if (pathContext == null)
{
throw new ArgumentNullException(nameof(pathContext));
}
_telemetryProvider = telemetryProvider ?? throw new ArgumentNullException(nameof(telemetryProvider));
try
{
_userPackageFolder = pathContext.UserPackageFolder;
_fallbackPackageFolders = pathContext.FallbackPackageFolders;
_solutionPackageFolder = solutionPackageFolder;
}
catch (Exception exception)
{
_telemetryProvider.PostFault(exception, typeof(VsPathContext).FullName);
throw;
}
}
private async ValueTask <object> CreatePackageFileServiceAsync(
ServiceMoniker moniker,
ServiceActivationOptions options,
IServiceBroker serviceBroker,
AuthorizationServiceClient authorizationServiceClient,
CancellationToken cancellationToken)
{
await _lazyInitializer.InitializeAsync(cancellationToken);
INuGetTelemetryProvider telemetryProvider = await _lazyTelemetryProvider.GetValueAsync(cancellationToken);
#pragma warning disable CA2000 // Dispose objects before losing scope
var service = new NuGetPackageFileService(
options,
serviceBroker,
authorizationServiceClient,
telemetryProvider);
#pragma warning restore CA2000 // Dispose objects before losing scope
return(service);
}
public VsGlobalPackagesInitScriptExecutor(IScriptExecutor scriptExecutor, INuGetTelemetryProvider telemetryProvider)
{
_scriptExecutor = scriptExecutor ?? throw new ArgumentNullException(nameof(scriptExecutor));
_telemetryProvider = telemetryProvider ?? throw new ArgumentNullException(nameof(telemetryProvider));
}
public NuGetProjectService(IVsSolutionManager solutionManager, ISettings settings, INuGetTelemetryProvider telemetryProvider)
{
_solutionManager = solutionManager ?? throw new ArgumentNullException(nameof(solutionManager));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
_telemetryProvider = telemetryProvider ?? throw new ArgumentNullException(nameof(telemetryProvider));
}
public VsFrameworkCompatibility(INuGetTelemetryProvider telemetryProvider)
{
_telemetryProvider = telemetryProvider;
}
public VsFrameworkParser(INuGetTelemetryProvider telemetryProvider)
{
_telemetryProvider = telemetryProvider;
}
