public PackageRestoreManager(ISourceRepositoryProvider sourceRepositoryProvider, ISettings settings, ISolutionManager solutionManager)
{
if(sourceRepositoryProvider == null)
{
throw new ArgumentNullException("sourceRepositoryProvider");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if(solutionManager == null)
{
throw new ArgumentNullException("solutionManager");
}
SourceRepositoryProvider = sourceRepositoryProvider;
Settings = settings;
SolutionManager = solutionManager;
SolutionManager.NuGetProjectAdded += OnNuGetProjectAdded;
SolutionManager.SolutionOpened += OnSolutionOpenedOrClosed;
SolutionManager.SolutionClosed += OnSolutionOpenedOrClosed;
}
public VsPackageInstaller(ISourceRepositoryProvider sourceRepositoryProvider, ISettings settings, ISolutionManager solutionManager, IVsPackageInstallerServices packageServices)
{
_sourceRepositoryProvider = sourceRepositoryProvider;
_settings = settings;
_solutionManager = solutionManager;
_projectContext = new VSAPIProjectContext();
_packageServices = packageServices;
}
public VSPackageRestoreManager(ISourceRepositoryProvider sourceRepositoryProvider, ISettings settings, ISolutionManager solutionManager)
: base(sourceRepositoryProvider, settings, solutionManager)
{
SolutionManager = solutionManager;
SolutionManager.NuGetProjectAdded += OnNuGetProjectAdded;
SolutionManager.SolutionOpened += OnSolutionOpenedOrClosed;
SolutionManager.SolutionClosed += OnSolutionOpenedOrClosed;
}
public void AddFromExtension(ISourceRepositoryProvider provider, string extensionId)
{
string path = GetExtensionRepositoryPath(extensionId, null, _errorHandler);
PackageSource source = new PackageSource(path);
_repositories.Add(provider.CreateRepository(source));
}
private void InitializeMandatory(ISourceRepositoryProvider sourceRepositoryProvider)
{
if (sourceRepositoryProvider == null)
{
throw new ArgumentNullException("sourceRepositoryProvider");
}
SourceRepositoryProvider = sourceRepositoryProvider;
}
/// <summary>
/// To construct a NuGetPackageManager that does not need a SolutionManager like NuGet.exe
/// </summary>
public NuGetPackageManager(ISourceRepositoryProvider sourceRepositoryProvider, string packagesFolderPath)
{
InitializeMandatory(sourceRepositoryProvider);
if(packagesFolderPath == null)
{
throw new ArgumentNullException("packagesFolderPath");
}
InitializePackagesFolderInfo(packagesFolderPath);
}
public MonoDevelopBuildIntegratedRestorer (
ISourceRepositoryProvider repositoryProvider,
ISettings settings)
{
sourceRepositories = repositoryProvider.GetRepositories ().ToList ();
this.settings = settings;
packageManagementEvents = PackageManagementServices.PackageManagementEvents;
context = CreateRestoreContext ();
}
public StandaloneUIContextFactory(ISourceRepositoryProvider repositoryProvider,
ISolutionManager solutionManager,
ISettings settings,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPage)
{
_repositoryProvider = repositoryProvider;
_solutionManager = solutionManager;
_settings = settings;
_restoreManager = packageRestoreManager;
_optionsPage = optionsPage;
}
public VisualStudioUIContextFactory([Import]ISourceRepositoryProvider repositoryProvider,
[Import]ISolutionManager solutionManager,
[Import]ISettings settings,
[Import]IPackageRestoreManager packageRestoreManager,
[Import]IOptionsPageActivator optionsPage)
{
_repositoryProvider = repositoryProvider;
_solutionManager = solutionManager;
_restoreManager = packageRestoreManager;
_optionsPage = optionsPage;
_settings = settings;
}
public MonoDevelopBuildIntegratedRestorer(
IMonoDevelopSolutionManager solutionManager,
ISourceRepositoryProvider repositoryProvider,
ISettings settings)
{
this.solutionManager = solutionManager;
sourceRepositories = repositoryProvider.GetRepositories().ToList();
this.settings = settings;
packageManagementEvents = PackageManagementServices.PackageManagementEvents;
context = CreateRestoreContext();
}
public VisualStudioUIContext(
NuGetPackage package,
ISourceRepositoryProvider sourceProvider,
ISolutionManager solutionManager,
NuGetPackageManager packageManager,
UIActionEngine uiActionEngine,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IEnumerable<NuGet.ProjectManagement.NuGetProject> projects) :
base(sourceProvider, solutionManager, packageManager, uiActionEngine, packageRestoreManager, optionsPageActivator, projects)
{
_package = package;
}
UpdatedNuGetPackagesProvider CreateProvider(
IMonoDevelopSolutionManager solutionManager,
IDotNetProject project,
ISourceRepositoryProvider sourceRepositoryProvider)
{
var nugetProject = CreateNuGetProject(solutionManager, project);
return(new UpdatedNuGetPackagesProvider(
project,
sourceRepositoryProvider,
nugetProject,
cancellationTokenSource.Token));
}
public PackageManagementContext(
ISourceRepositoryProvider sourceRepositoryProvider,
ISolutionManager solutionManager,
ISettings settings,
ISourceControlManagerProvider sourceControlManagerProvider,
ICommonOperations commonOperations)
{
SourceRepositoryProvider = sourceRepositoryProvider;
VsSolutionManager = solutionManager;
Settings = settings;
SourceControlManagerProvider = sourceControlManagerProvider;
CommonOperations = commonOperations;
}
public UpdatedNuGetPackagesProvider(
IDotNetProject dotNetProject,
ISourceRepositoryProvider sourceRepositoryProvider,
NuGetProject project,
CancellationToken cancellationToken = default(CancellationToken))
{
this.dotNetProject = dotNetProject;
this.project = project;
this.sourceRepositories = sourceRepositoryProvider.GetRepositories().ToList();
this.cancellationToken = cancellationToken;
}
public PackageManagementContext(
ISourceRepositoryProvider sourceRepositoryProvider,
ISolutionManager solutionManager,
NuGet.Configuration.ISettings settings,
ISourceControlManagerProvider sourceControlManagerProvider,
ICommonOperations commonOperations)
{
SourceRepositoryProvider = sourceRepositoryProvider;
VsSolutionManager = solutionManager;
Settings = settings;
SourceControlManagerProvider = sourceControlManagerProvider;
CommonOperations = commonOperations;
}
internal SharedServiceState(ISourceRepositoryProvider sourceRepositoryProvider)
{
SourceRepositoryProvider = sourceRepositoryProvider;
SourceRepositoryProvider.PackageSourceProvider.PackageSourcesChanged += PackageSourcesChanged;
SolutionManager = new AsyncLazy <IVsSolutionManager>(
ServiceLocator.GetComponentModelServiceAsync <IVsSolutionManager>,
NuGetUIThreadHelper.JoinableTaskFactory);
SourceRepositories = new AsyncLazy <IReadOnlyCollection <SourceRepository> >(
GetSourceRepositoriesAsync,
NuGetUIThreadHelper.JoinableTaskFactory);
}
public VsPackageUninstaller(
ISourceRepositoryProvider sourceRepositoryProvider,
Configuration.ISettings settings,
IVsSolutionManager solutionManager,
IDeleteOnRestartManager deleteOnRestartManager)
{
_sourceRepositoryProvider = sourceRepositoryProvider;
_settings = settings;
_solutionManager = solutionManager;
PumpingJTF = new PumpingJTF(NuGetUIThreadHelper.JoinableTaskFactory);
_deleteOnRestartManager = deleteOnRestartManager;
}
public VisualStudioUIContext(
NuGetPackage package,
ISourceRepositoryProvider sourceProvider,
ISolutionManager solutionManager,
NuGetPackageManager packageManager,
UIActionEngine uiActionEngine,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IEnumerable <NuGet.ProjectManagement.NuGetProject> projects) :
base(sourceProvider, solutionManager, packageManager, uiActionEngine, packageRestoreManager, optionsPageActivator, projects)
{
_package = package;
}
public async Task Simple_WhenCancelled_Reports_Cancelled_Async()
{
var restoreMan = Mock.Of <IPackageRestoreManager>();
_globalProvider.AddService(typeof(IPackageRestoreManager), restoreMan);
var slnMan = Mock.Of <IVsSolutionManager>();
_globalProvider.AddService(typeof(IVsSolutionManager), slnMan);
ISourceRepositoryProvider sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
_globalProvider.AddService(typeof(ISourceRepositoryProvider), sourceRepositoryProvider);
var restoreChecker = Mock.Of <ISolutionRestoreChecker>();
var eventsPublisher = Mock.Of <IRestoreEventsPublisher>();
var settings = Mock.Of <ISettings>();
Mock.Get(settings)
.Setup(x => x.GetSection("packageRestore"))
.Returns(() => new VirtualSettingSection("packageRestore",
new AddItem("automatic", bool.TrueString)));
var consoleProvider = Mock.Of <IOutputConsoleProvider>();
var logger = new RestoreOperationLogger(new Lazy <IOutputConsoleProvider>(() => consoleProvider));
var job = new SolutionRestoreJob(
asyncServiceProvider: AsyncServiceProvider.GlobalProvider,
packageRestoreManager: restoreMan,
solutionManager: slnMan,
sourceRepositoryProvider: sourceRepositoryProvider,
restoreEventsPublisher: eventsPublisher,
settings: settings,
solutionRestoreChecker: restoreChecker);
var restoreRequest = new SolutionRestoreRequest(
forceRestore: true,
RestoreOperationSource.OnBuild);
var restoreJobContext = new SolutionRestoreJobContext();
var cts = new CancellationTokenSource();
cts.Cancel();
await job.ExecuteAsync(
request : restoreRequest,
jobContext : restoreJobContext,
logger : logger,
isSolutionLoadRestore : true,
token : cts.Token);
Assert.Equal(NuGetOperationStatus.Cancelled, job.Status);
}
public VsPackageInstaller(
ISourceRepositoryProvider sourceRepositoryProvider,
ISettings settings,
IVsSolutionManager solutionManager,
IDeleteOnRestartManager deleteOnRestartManager)
{
_sourceRepositoryProvider = sourceRepositoryProvider;
_settings = settings;
_solutionManager = solutionManager;
_deleteOnRestartManager = deleteOnRestartManager;
_isCPSJTFLoaded = false;
PumpingJTF = new PumpingJTF(NuGetUIThreadHelper.JoinableTaskFactory);
}
private async ValueTask <SourceRepository?> GetSourceRepositoryAsync(CancellationToken cancellationToken)
{
ISourceRepositoryProvider sourceRepositoryProvider = await _state.SourceRepositoryProvider.GetValueAsync(cancellationToken);
Assumes.NotNull(sourceRepositoryProvider);
var activeSources = new List <SourceRepository>();
PackageSourceMoniker
.PopulateList(sourceRepositoryProvider)
.ForEach(source => activeSources.AddRange(source.SourceRepositories));
return(activeSources.FirstOrDefault());
}
public PreinstalledPackageInstaller(
IVsPackageInstallerServices packageServices,
ISolutionManager solutionManager,
ISettings settings,
ISourceRepositoryProvider sourceProvider,
VsPackageInstaller installer)
{
//_websiteHandler = websiteHandler;
_packageServices = packageServices;
//_vsCommonOperations = vsCommonOperations;
_solutionManager = solutionManager;
_sourceProvider = sourceProvider;
_installer = installer;
}
public LocalPackagesLoaderService(IDirectoryService directoryService, IRepositoryContextService repositoryService, IExtensibleProjectLocator extensibleProjectLocator,
INuGetPackageManager nuGetExtensibleProjectManager, ISourceRepositoryProvider repositoryProvider)
{
Argument.IsNotNull(() => directoryService);
Argument.IsNotNull(() => extensibleProjectLocator);
Argument.IsNotNull(() => nuGetExtensibleProjectManager);
Argument.IsNotNull(() => repositoryService);
_extensibleProjectLocator = extensibleProjectLocator;
_projectManager = nuGetExtensibleProjectManager;
_repositoryProvider = repositoryProvider;
_directoryService = directoryService;
_repositoryService = repositoryService;
}
public StandaloneUIContext(
string settingsFile,
ISourceRepositoryProvider sourceProvider,
ISolutionManager solutionManager,
NuGetPackageManager packageManager,
UIActionEngine uiActionEngine,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IEnumerable<NuGet.ProjectManagement.NuGetProject> projects) :
base(sourceProvider, solutionManager, packageManager, uiActionEngine, packageRestoreManager, optionsPageActivator, projects)
{
_settingsFile = settingsFile;
LoadSettings();
}
public StandaloneUIContext(
string settingsFile,
ISourceRepositoryProvider sourceProvider,
ISolutionManager solutionManager,
NuGetPackageManager packageManager,
UIActionEngine uiActionEngine,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IEnumerable <NuGet.ProjectManagement.NuGetProject> projects) :
base(sourceProvider, solutionManager, packageManager, uiActionEngine, packageRestoreManager, optionsPageActivator, projects)
{
_settingsFile = settingsFile;
LoadSettings();
}
public PreinstalledPackageInstaller(
IVsPackageInstallerServices packageServices,
IVsSolutionManager solutionManager,
Configuration.ISettings settings,
ISourceRepositoryProvider sourceProvider,
VsPackageInstaller installer,
IVsProjectAdapterProvider vsProjectAdapterProvider)
{
_packageServices = packageServices;
_solutionManager = solutionManager;
_sourceProvider = sourceProvider;
_vsProjectAdapterProvider = vsProjectAdapterProvider;
_installer = installer;
}
public PreinstalledPackageInstaller(
IVsPackageInstallerServices packageServices,
ISolutionManager solutionManager,
Configuration.ISettings settings,
ISourceRepositoryProvider sourceProvider,
VsPackageInstaller installer)
{
//_websiteHandler = websiteHandler;
_packageServices = packageServices;
//_vsCommonOperations = vsCommonOperations;
_solutionManager = solutionManager;
_sourceProvider = sourceProvider;
_installer = installer;
}
public PackageSourcesOptionsControl(ISourceRepositoryProvider sourceRepositoryProvider, IServiceProvider serviceProvider)
{
InitializeComponent();
if(sourceRepositoryProvider == null)
{
throw new ArgumentNullException("sourceRepositoryProvider");
}
_serviceProvider = serviceProvider;
_packageSourceProvider = sourceRepositoryProvider.PackageSourceProvider;
SetupEventHandlers();
UpdateDPI();
}
public SolutionRestoreJob(
IPackageRestoreManager packageRestoreManager,
IVsSolutionManager solutionManager,
ISourceRepositoryProvider sourceRepositoryProvider,
IRestoreEventsPublisher restoreEventsPublisher,
ISettings settings)
: this(AsyncServiceProvider.GlobalProvider,
packageRestoreManager,
solutionManager,
sourceRepositoryProvider,
restoreEventsPublisher,
settings
)
{
}
public VsPackageInstaller(
ISourceRepositoryProvider sourceRepositoryProvider,
Configuration.ISettings settings,
ISolutionManager solutionManager,
IVsPackageInstallerServices packageServices,
IDeleteOnRestartManager deleteOnRestartManager)
{
_sourceRepositoryProvider = sourceRepositoryProvider;
_settings = settings;
_solutionManager = solutionManager;
_projectContext = new VSAPIProjectContext();
_packageServices = packageServices;
_deleteOnRestartManager = deleteOnRestartManager;
PumpingJTF = new PumpingJTF(ThreadHelper.JoinableTaskContext);
}
public PackageRepositoryBrowser(ISourceRepositoryProvider sourceRepositoryProvider, IPackageRepositoryFactory packageRepositoryFactory)
{
if (sourceRepositoryProvider == null)
{
throw new ArgumentNullException("sourceRepositoryProvider");
}
if (packageRepositoryFactory == null)
{
throw new ArgumentNullException("packageRepositoryFactory");
}
this.repositoryConfigurations = sourceRepositoryProvider.GetRepositoryConfigurations().ToArray();
this.repositories = this.repositoryConfigurations.Select(r => packageRepositoryFactory.CreateRepository(r.Url.ToString())).ToArray();
}
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 MonoDevelopBuildIntegratedRestorer(
ISourceRepositoryProvider repositoryProvider,
ISettings settings,
string solutionDirectory)
{
sourceRepositories = repositoryProvider.GetRepositories().ToList();
packageManagementEvents = PackageManagementServices.PackageManagementEvents;
packagesFolder = BuildIntegratedProjectUtility.GetEffectiveGlobalPackagesFolder(
solutionDirectory,
settings);
context = CreateRestoreContext();
}
public PackageSourcesOptionsControl(ISourceRepositoryProvider sourceRepositoryProvider, IServiceProvider serviceProvider)
{
InitializeComponent();
if (sourceRepositoryProvider == null)
{
throw new ArgumentNullException("sourceRepositoryProvider");
}
_serviceProvider = serviceProvider;
_packageSourceProvider = sourceRepositoryProvider.PackageSourceProvider;
SetupEventHandlers();
UpdateDPI();
}
private void InitNuGet()
{
_nugetSettings = Settings.LoadDefaultSettings(root: null);
_nugetSourceRepositoryProvider = new SourceRepositoryProvider(_nugetSettings, Repository.Provider.GetCoreV3());
_nuGetFramework = NuGetFramework.ParseFolder("netstandard2.0");
_packagesDirectory = _fileSystemManager.BuildFilePath(Path.Combine(_neonConfig.Plugins.Directory, "packages"));
_fileSystemManager.CreateDirectory(Path.Combine(_neonConfig.Plugins.Directory, "packages"));
_packagePathResolver = new PackagePathResolver(_packagesDirectory);
_packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(_nugetSettings, NullLogger.Instance), NullLogger.Instance);
}
private static ISettings PopulateSettingsWithSources(
ISourceRepositoryProvider sourceRepositoryProvider, TestDirectory settingsDirectory)
{
var settings = new Settings(settingsDirectory);
foreach (var source in sourceRepositoryProvider.GetRepositories())
{
settings.SetValue(
ConfigurationConstants.PackageSources,
ConfigurationConstants.PackageSources,
source.PackageSource.Source);
}
return(settings);
}
public VisualStudioUIContextFactory([Import] ISourceRepositoryProvider repositoryProvider,
[Import] ISolutionManager solutionManager,
[Import] ISettings settings,
[Import] IPackageRestoreManager packageRestoreManager,
[Import] IOptionsPageActivator optionsPage,
[Import] IDeleteOnRestartManager deleteOnRestartManager,
[ImportMany] IEnumerable <Lazy <IVsPackageManagerProvider, IOrderable> > packageManagerProviders)
{
_repositoryProvider = repositoryProvider;
_solutionManager = solutionManager;
_restoreManager = packageRestoreManager;
_optionsPage = optionsPage;
_settings = settings;
_deleteOnRestartManager = deleteOnRestartManager;
_packageManagerProviders = PackageManagerProviderUtility.Sort(packageManagerProviders, MaxPackageManager);
}
/// <summary>
/// Preprocess to get resourceRepositoryProvider and solutionManager from packageManagementContext.
/// </summary>
protected virtual void Preprocess()
{
_packageManagementContext = (PackageManagementContext)GetPropertyValueFromHost(PackageManagementContextKey);
if (_packageManagementContext != null)
{
_resourceRepositoryProvider = _packageManagementContext.SourceRepositoryProvider;
_solutionManager = _packageManagementContext.VsSolutionManager;
_settings = _packageManagementContext.Settings;
_commonOperations = _packageManagementContext.CommonOperations;
if (_commonOperations != null)
{
ExecutionContext = new IDEExecutionContext(_commonOperations);
}
}
_dte = (DTE)GetPropertyValueFromHost(DTEKey);
}
public VSPackageRestoreManager(
ISourceRepositoryProvider sourceRepositoryProvider,
Configuration.ISettings settings,
ISolutionManager solutionManager)
: base(sourceRepositoryProvider, settings, solutionManager)
{
if (solutionManager == null)
{
throw new ArgumentNullException(nameof(solutionManager));
}
SolutionManager = solutionManager;
SolutionManager.NuGetProjectAdded += OnNuGetProjectAdded;
SolutionManager.SolutionOpened += OnSolutionOpenedOrClosed;
SolutionManager.SolutionClosed += OnSolutionOpenedOrClosed;
}
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);
}
public UpdateNuGetPackageAction(
IMonoDevelopSolutionManager solutionManager,
IDotNetProject dotNetProject,
INuGetProjectContext projectContext,
INuGetPackageManager packageManager,
IPackageManagementEvents packageManagementEvents)
{
this.dotNetProject = dotNetProject;
this.context = projectContext;
this.packageManager = packageManager;
this.packageManagementEvents = packageManagementEvents;
project = solutionManager.GetNuGetProject(dotNetProject);
sourceRepositoryProvider = solutionManager.CreateSourceRepositoryProvider();
primarySources = sourceRepositoryProvider.GetRepositories().ToList();
}
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));
}
IEnumerable <SourceRepositoryViewModel> GetPackageSources()
{
ISourceRepositoryProvider provider = solutionManager.CreateSourceRepositoryProvider();
packageSourceProvider = provider.PackageSourceProvider;
var repositories = provider.GetRepositories().ToList();
if (repositories.Count > 1)
{
yield return(new AggregateSourceRepositoryViewModel(repositories));
}
foreach (SourceRepository repository in repositories)
{
yield return(new SourceRepositoryViewModel(repository));
}
}
public UpdateNuGetPackageAction (
IMonoDevelopSolutionManager solutionManager,
IDotNetProject dotNetProject,
INuGetProjectContext projectContext,
INuGetPackageManager packageManager,
IPackageManagementEvents packageManagementEvents)
{
this.dotNetProject = dotNetProject;
this.context = projectContext;
this.packageManager = packageManager;
this.packageManagementEvents = packageManagementEvents;
project = solutionManager.GetNuGetProject (dotNetProject);
sourceRepositoryProvider = solutionManager.CreateSourceRepositoryProvider ();
primarySources = sourceRepositoryProvider.GetRepositories ().ToList ();
}
public PreinstalledPackageInstaller(
#pragma warning disable CS0618 // Type or member is obsolete
IVsPackageInstallerServices packageServices,
#pragma warning restore CS0618 // Type or member is obsolete
IVsSolutionManager solutionManager,
Configuration.ISettings settings,
ISourceRepositoryProvider sourceProvider,
VsPackageInstaller installer,
IVsProjectAdapterProvider vsProjectAdapterProvider)
{
_packageServices = packageServices;
_solutionManager = solutionManager;
_sourceProvider = sourceProvider;
_vsProjectAdapterProvider = vsProjectAdapterProvider;
_installer = installer;
_settings = settings;
}
/// <summary>
/// To construct a NuGetPackageManager with a mandatory SolutionManager lke VS
/// </summary>
public NuGetPackageManager(ISourceRepositoryProvider sourceRepositoryProvider, ISettings settings, ISolutionManager solutionManager/*, IPackageResolver packageResolver */)
{
InitializeMandatory(sourceRepositoryProvider);
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if(solutionManager == null)
{
throw new ArgumentNullException("solutionManager");
}
Settings = settings;
SolutionManager = solutionManager;
InitializePackagesFolderInfo(PackagesFolderPathUtility.GetPackagesFolderPath(SolutionManager, Settings));
}
public NuGetUIContextBase(
ISourceRepositoryProvider sourceProvider,
ISolutionManager solutionManager,
NuGetPackageManager packageManager,
UIActionEngine uiActionEngine,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IEnumerable<NuGetProject> projects)
{
_sourceProvider = sourceProvider;
_solutionManager = solutionManager;
_packageManager = packageManager;
_uiActionEngine = uiActionEngine;
_packageManager = packageManager;
_packageRestoreManager = packageRestoreManager;
_optionsPageActivator = optionsPageActivator;
_projects = projects.ToArray();
}
public VsTemplateWizard(
IVsPackageInstaller installer,
IVsPackageInstallerServices packageServices,
IOutputConsoleProvider consoleProvider,
ISolutionManager solutionManager,
ISettings settings,
ISourceRepositoryProvider sourceProvider
)
{
_installer = installer;
_packageServices = packageServices;
_consoleProvider = consoleProvider;
_solutionManager = solutionManager;
_settings = settings;
_sourceProvider = sourceProvider;
_preinstalledPackageInstaller = new PreinstalledPackageInstaller(_packageServices, _solutionManager, _settings, _sourceProvider, (VsPackageInstaller)_installer);
}
private static string[] GetEnabledPackageSources(ISourceRepositoryProvider sourceRepositoryProvider)
{
var enabledSources = sourceRepositoryProvider
.GetRepositories()
.Where(r => r.PackageSource.IsEnabled)
.ToArray();
var packageSources = new List <string>();
if (enabledSources.Length > 1)
{
packageSources.Add(AggregateSourceName);
}
packageSources.AddRange(
enabledSources.Select(r => r.PackageSource.Name));
return(packageSources.ToArray());
}
protected PowerShellHost(string name, IRunspaceManager runspaceManager)
{
_runspaceManager = runspaceManager;
// TODO: Take these as ctor arguments
_sourceRepositoryProvider = ServiceLocator.GetInstance<ISourceRepositoryProvider>();
_solutionManager = ServiceLocator.GetInstance<ISolutionManager>();
_settings = ServiceLocator.GetInstance<ISettings>();
_dte = ServiceLocator.GetInstance<DTE>();
_sourceControlManagerProvider = ServiceLocator.GetInstanceSafe<ISourceControlManagerProvider>();
_commonOperations = ServiceLocator.GetInstanceSafe<ICommonOperations>();
_packageManagementContext = new PackageManagementContext(_sourceRepositoryProvider, _solutionManager,
_settings, _sourceControlManagerProvider, _commonOperations);
_name = name;
IsCommandEnabled = true;
InitializeSources();
_sourceRepositoryProvider.PackageSourceProvider.PackageSourcesSaved += PackageSourceProvider_PackageSourcesSaved;
}
/// <summary>
/// Create a UIActionEngine to perform installs/uninstalls
/// </summary>
public UIActionEngine(ISourceRepositoryProvider sourceProvider, NuGetPackageManager packageManager)
{
_sourceProvider = sourceProvider;
_packageManager = packageManager;
}
public VsPackageInstallerServices(ISolutionManager solutionManager, ISourceRepositoryProvider sourceRepositoryProvider, ISettings settings)
{
_solutionManager = solutionManager;
_sourceRepositoryProvider = sourceRepositoryProvider;
_settings = settings;
}
public VsPackageUninstaller(ISourceRepositoryProvider sourceRepositoryProvider, ISettings settings, ISolutionManager solutionManager)
{
_sourceRepositoryProvider = sourceRepositoryProvider;
_settings = settings;
_solutionManager = solutionManager;
}
public PreinstalledRepositoryProvider(Action<string> errorHandler, ISourceRepositoryProvider provider)
{
_repositories = new List<SourceRepository>();
_errorHandler = errorHandler;
_provider = provider;
}
internal async Task InstallInternal(Project project, List<PackageDependency> packages, ISourceRepositoryProvider repoProvider, bool skipAssemblyReferences, bool ignoreDependencies, CancellationToken token)
{
foreach (var group in packages.GroupBy(e => e.Id, StringComparer.OrdinalIgnoreCase))
{
if (group.Count() > 1)
{
// throw if a package id appears more than once
throw new InvalidOperationException(VsResources.InvalidPackageList);
}
}
// find the latest package
List<MetadataResource> metadataResources = new List<MetadataResource>();
// create the resources for looking up the latest version
foreach (var repo in repoProvider.GetRepositories())
{
MetadataResource resource = await repo.GetResourceAsync<MetadataResource>();
if (resource != null)
{
metadataResources.Add(resource);
}
}
// find the highest version within the ranges
var idToIdentity = new Dictionary<string, PackageIdentity>(StringComparer.OrdinalIgnoreCase);
foreach (var dep in packages)
{
NuGetVersion highestVersion = null;
if (dep.VersionRange != null
&& VersionComparer.Default.Equals(dep.VersionRange.MinVersion, dep.VersionRange.MaxVersion)
&& dep.VersionRange.MinVersion != null)
{
// this is a single version, not a range
highestVersion = dep.VersionRange.MinVersion;
}
else
{
var tasks = new List<Task<IEnumerable<NuGetVersion>>>();
foreach (var resource in metadataResources)
{
tasks.Add(resource.GetVersions(dep.Id, token));
}
var versions = await Task.WhenAll(tasks.ToArray());
highestVersion = versions.SelectMany(v => v).Where(v => dep.VersionRange.Satisfies(v)).Max();
}
if (highestVersion == null)
{
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, VsResources.UnknownPackage, dep.Id));
}
if (!idToIdentity.ContainsKey(dep.Id))
{
idToIdentity.Add(dep.Id, new PackageIdentity(dep.Id, highestVersion));
}
}
// Skip assembly references and disable binding redirections should be done together
bool disableBindingRedirects = skipAssemblyReferences;
VSAPIProjectContext projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects);
await InstallInternal(project, idToIdentity.Values.ToList(), repoProvider, projectContext, ignoreDependencies, token);
}
public ProjectTemplateSourceRepositoryProvider ()
{
provider = SourceRepositoryProviderFactory.CreateSourceRepositoryProvider ();
var packageSource = new PackageSource (NuGetConstants.V3FeedUrl);
nugetSourceRepository = provider.CreateRepository (packageSource);
}
/// <summary>
/// Core install method. All installs from the VS API and template wizard end up here.
/// </summary>
internal async Task InstallInternal(Project project, List<PackageIdentity> packages, ISourceRepositoryProvider repoProvider, VSAPIProjectContext projectContext, bool ignoreDependencies, CancellationToken token)
{
// store expanded node state
IDictionary<string, ISet<VsHierarchyItem>> expandedNodes = VsHierarchyHelper.GetAllExpandedNodes(_solutionManager);
try
{
DependencyBehavior depBehavior = ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior.Lowest;
bool includePrerelease = false;
ResolutionContext resolution = new ResolutionContext(depBehavior, includePrerelease, false);
NuGetPackageManager packageManager = new NuGetPackageManager(repoProvider, _settings, _solutionManager);
// find the project
NuGetProject nuGetProject = PackageManagementHelpers.GetProject(_solutionManager, project, projectContext);
// install the package
foreach (PackageIdentity package in packages)
{
if (package.Version == null)
{
if (!_packageServices.IsPackageInstalled(project, package.Id))
{
await packageManager.InstallPackageAsync(nuGetProject, package.Id, resolution, projectContext, repoProvider.GetRepositories(), Enumerable.Empty<SourceRepository>(), token);
}
}
else
{
if (!_packageServices.IsPackageInstalledEx(project, package.Id, package.Version.ToString()))
{
await packageManager.InstallPackageAsync(nuGetProject, package, resolution, projectContext, repoProvider.GetRepositories(), Enumerable.Empty<SourceRepository>(), token);
}
}
}
}
finally
{
// collapse nodes
VsHierarchyHelper.CollapseAllNodes(_solutionManager, expandedNodes);
}
}
public RepositorySourceConfigurationCommand(IUserInterface userInterface, IRepositoryConfigurationCommandActionParser repositoryConfigurationCommandActionParser, ISourceRepositoryProvider sourceRepositoryProvider)
{
if (userInterface == null)
{
throw new ArgumentNullException("userInterface");
}
if (repositoryConfigurationCommandActionParser == null)
{
throw new ArgumentNullException("repositoryConfigurationCommandActionParser");
}
if (sourceRepositoryProvider == null)
{
throw new ArgumentNullException("sourceRepositoryProvider");
}
this.userInterface = userInterface;
this.repositoryConfigurationCommandActionParser = repositoryConfigurationCommandActionParser;
this.sourceRepositoryProvider = sourceRepositoryProvider;
this.Attributes = new CommandAttributes
{
CommandName = CommandName,
AlternativeCommandNames = this.AlternativeCommandNames,
RequiredArguments = new[] { ArgumentNameAction, ArgumentNameRepositoryName, ArgumentNameRepositoryUrl },
PositionalArguments = new[] { ArgumentNameAction, ArgumentNameRepositoryName, ArgumentNameRepositoryUrl },
Description = Resources.RepositorySourceConfigurationCommand.CommandDescriptionText,
Usage =
string.Format(
"{0} <{1}> <{2}> <{3}>", CommandName, string.Join("|", this.AllowedActions), ArgumentNameRepositoryName, ArgumentNameRepositoryUrl),
Examples =
new Dictionary<string, string>
{
{
string.Format(
"{0} {1} \"{2}\" \"{3}\"",
CommandName,
RepositoryConfigurationCommandAction.Add,
Resources.RepositorySourceConfigurationCommand.SampleRepositoryName,
NuDeployConstants.DefaultFeedUrl),
Resources.RepositorySourceConfigurationCommand.AddCommandExampleDescriptionNamedArguments
},
{
string.Format(
"{0} -{1}={2} -{3}=\"{4}\" -{5}=\"{6}\"",
CommandName,
ArgumentNameAction,
RepositoryConfigurationCommandAction.Add,
ArgumentNameRepositoryName,
Resources.RepositorySourceConfigurationCommand.SampleRepositoryName,
ArgumentNameRepositoryUrl,
NuDeployConstants.DefaultFeedUrl),
Resources.RepositorySourceConfigurationCommand.AddCommandExampleDescriptionNamedArguments
},
{
string.Format(
"{0} {1} \"{2}\"",
CommandName,
RepositoryConfigurationCommandAction.Delete,
Resources.RepositorySourceConfigurationCommand.SampleRepositoryName),
Resources.RepositorySourceConfigurationCommand.DeleteCommandExampleDescriptionPositionalArguments
},
{
string.Format("{0} {1}", CommandName, RepositoryConfigurationCommandAction.Reset),
Resources.RepositorySourceConfigurationCommand.ResetCommandExampleDescription
},
{
string.Format("{0} {1}", CommandName, RepositoryConfigurationCommandAction.List),
Resources.RepositorySourceConfigurationCommand.ListCommandExampleDescription
}
},
ArgumentDescriptions =
new Dictionary<string, string>
{
{
ArgumentNameAction,
string.Format(
Resources.RepositorySourceConfigurationCommand.ArgumentDescriptionRepositoryActionTemplate,
string.Join(", ", this.AllowedActions))
},
{ ArgumentNameRepositoryName, Resources.RepositorySourceConfigurationCommand.ArgumentDescriptionRepositoryName },
{ ArgumentNameRepositoryUrl, Resources.RepositorySourceConfigurationCommand.ArgumentDescriptionRepositoryUrl }
}
};
this.Arguments = new Dictionary<string, string>();
}
