private async Task <IEnumerable <NuGetProjectAction> > PacManCleanInstall(SourceRepositoryProvider sourceRepositoryProvider, PackageIdentity target) { // Arrange using (var testSolutionManager = new TestSolutionManager()) using (var randomPackagesConfigFolderPath = TestDirectory.Create()) { var testSettings = NullSettings.Instance; var token = CancellationToken.None; var deleteOnRestartManger = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManger); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config"); var projectTargetFramework = NuGetFramework.Parse("net45"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigFolderPath); // Act var nugetProjectActions = await nuGetPackageManager.PreviewInstallPackageAsync(msBuildNuGetProject, target, new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); return(nugetProjectActions); } }
/// <summary> /// Finds the NuGetProject from a DTE project /// </summary> public static async Task <NuGetProject> GetProjectAsync(ISolutionManager solutionManager, Project project, VSAPIProjectContext projectContext = null) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); if (solutionManager == null) { throw new ArgumentNullException("solution"); } var projectSafeName = await EnvDTEProjectUtility.GetCustomUniqueNameAsync(project); NuGetProject nuGetProject = solutionManager.GetNuGetProject(projectSafeName); var settings = ServiceLocator.GetInstance <Configuration.ISettings>(); // if the project does not exist in the solution (this is true for new templates) create it manually if (nuGetProject == null) { VSNuGetProjectFactory factory = new VSNuGetProjectFactory(() => PackagesFolderPathUtility.GetPackagesFolderPath(solutionManager, settings)); nuGetProject = factory.CreateNuGetProject(project, projectContext); } return(nuGetProject); }
public async Task <NuGetProject> UpgradeProjectToPackageReferenceAsync(NuGetProject oldProject) { Assumes.Present(oldProject); var projectName = await GetNuGetProjectSafeNameAsync(oldProject); var vsProjectAdapter = await GetVsProjectAdapterAsync(projectName); _projectSystemCache.TryGetProjectNames(projectName, out var projectNames); RemoveVsProjectAdapterFromCache(projectName); var context = new ProjectProviderContext( EmptyNuGetProjectContext, () => PackagesFolderPathUtility.GetPackagesFolderPath(this, _settings.Value)); var nuGetProject = await _projectSystemFactory.CreateNuGetProjectAsync <LegacyPackageReferenceProject>( vsProjectAdapter, context); var added = _projectSystemCache.AddProject(projectNames, vsProjectAdapter, nuGetProject); if (DefaultNuGetProjectName == null) { DefaultNuGetProjectName = projectName; } NuGetProjectUpdated?.Invoke(this, new NuGetProjectEventArgs(nuGetProject)); return(nuGetProject); }
public bool TryCreateSolutionContext(string solutionDirectory, out IVsPathContext2 outputPathContext) { const string eventName = nameof(IVsPathContextProvider2) + "." + nameof(TryCreateSolutionContext) + ".2"; using var _ = NuGetETW.ExtensibilityEventSource.StartStopEvent(eventName); if (solutionDirectory == null) { throw new ArgumentNullException(nameof(solutionDirectory)); } try { var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(solutionDirectory, _settings.Value); outputPathContext = new VsPathContext(NuGetPathContext.Create(_settings.Value), _telemetryProvider, packagesFolderPath); return(outputPathContext != null); } catch (Exception exception) { _telemetryProvider.PostFault(exception, typeof(VsPathContextProvider).FullName); throw; } }
public Task InitialAsync() { List <Lazy <INuGetResourceProvider> > _resourceProviders = new List <Lazy <INuGetResourceProvider> >(); _resourceProviders.AddRange(FactoryExtensionsV3.GetCoreV3(Repository.Provider)); SolutionDirectory = _solutionDiretoryManager.DiretoryPath; Settings = _nuGetSettingsAccessor.Settings.Value; PackagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(SolutionDirectory, Settings); _packageSourceProvider = new PackageSourceProvider(Settings); _sourceRepositoryProvider = new SourceRepositoryProvider(_packageSourceProvider, _resourceProviders); _packageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, ClientPolicyContext.GetClientPolicy(Settings, _logger), _logger); _packageManager = CreatePackageManager(); return(Task.CompletedTask); }
public NuGetProject CreateNuGetProject(DotNetProject project, INuGetProjectContext context) { Runtime.AssertMainThread(); var projectSystem = new MonoDevelopMSBuildNuGetProjectSystem(project, context); string projectJsonPath = ProjectJsonPathUtilities.GetProjectConfigPath(project.BaseDirectory, project.Name); if (File.Exists(projectJsonPath)) { return(new BuildIntegratedProjectSystem( projectJsonPath, project.FileName, project, projectSystem, project.Name, settings)); } string baseDirectory = GetBaseDirectory(project); string folderNuGetProjectFullPath = PackagesFolderPathUtility.GetPackagesFolderPath(baseDirectory, settings); string packagesConfigFolderPath = project.BaseDirectory; return(new MSBuildNuGetProject( projectSystem, folderNuGetProjectFullPath, packagesConfigFolderPath)); }
private void AddTemplateParameters(Dictionary <string, string> replacementsDictionary) { ThreadHelper.ThrowIfNotOnUIThread(); // add the $nugetpackagesfolder$ parameter which returns relative path to the solution's packages folder. // this is used by project templates to include assembly references directly inside the template project file // without relying on nuget to install the actual packages. string targetInstallDir; if (replacementsDictionary.TryGetValue("$destinationdirectory$", out targetInstallDir)) { string solutionRepositoryPath = null; if (_dte.Solution != null && _dte.Solution.IsOpen) { //solutionRepositoryPath = RepositorySettings.Value.RepositoryPath; solutionRepositoryPath = PackagesFolderPathUtility.GetPackagesFolderPath(_solutionManager, _settings); } else { string solutionDir = DetermineSolutionDirectory(replacementsDictionary); if (!String.IsNullOrEmpty(solutionDir)) { // If the project is a Website that is created on an Http location, // solutionDir may be an Http address, e.g. http://localhost. // In that case, we have to use forward slash instead of backward one. if (Uri.IsWellFormedUriString(solutionDir, UriKind.Absolute)) { solutionRepositoryPath = PathUtility.EnsureTrailingForwardSlash(solutionDir) + DefaultRepositoryDirectory; } else { solutionRepositoryPath = Path.Combine(solutionDir, DefaultRepositoryDirectory); } } } if (solutionRepositoryPath != null) { // If the project is a Website that is created on an Http location, // targetInstallDir may be an Http address, e.g. http://localhost. // In that case, we have to use forward slash instead of backward one. if (Uri.IsWellFormedUriString(targetInstallDir, UriKind.Absolute)) { targetInstallDir = PathUtility.EnsureTrailingForwardSlash(targetInstallDir); } else { targetInstallDir = PathUtility.EnsureTrailingSlash(targetInstallDir); } replacementsDictionary["$nugetpackagesfolder$"] = PathUtility.EnsureTrailingSlash(PathUtility.GetRelativePath(targetInstallDir, solutionRepositoryPath)); } } // provide a current timpestamp (for use by universal provider) replacementsDictionary["$timestamp$"] = DateTime.Now.ToString("yyyyMMddHHmmss"); }
protected async Task <NuGetProject> CreateProjectAsync(IProjectAdapter projectAdapter, INuGetProjectContext nuGetProjectContext = null) { var context = new ProjectProviderContext( nuGetProjectContext ?? EmptyNuGetProjectContext, () => PackagesFolderPathUtility.GetPackagesFolderPath(this, NuGetSettings)); return(await _nuGetProjectFactory.TryCreateNuGetProjectAsync(projectAdapter, context)); }
public bool TryCreateSolutionContext(out IVsPathContext2 outputPathContext) { var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(_solutionManager.Value, _settings.Value); outputPathContext = GetSolutionPathContext(packagesFolderPath); return(outputPathContext != null); }
private async Task <NuGetProject> CreateNuGetProjectAsync(IVsProjectAdapter project, INuGetProjectContext projectContext = null) { var context = new ProjectProviderContext( projectContext ?? EmptyNuGetProjectContext, () => PackagesFolderPathUtility.GetPackagesFolderPath(this, _settings.Value)); return(await _projectSystemFactory.TryCreateNuGetProjectAsync(project, context)); }
private VSNuGetProjectFactory GetProjectFactory() { var settings = ServiceLocator.GetInstance <ISettings>(); // We are doing this to avoid a loop at initialization. We probably want to remove this dependency altogether. var factory = new VSNuGetProjectFactory(() => PackagesFolderPathUtility.GetPackagesFolderPath(this, settings)); return(factory); }
private async Task<SourceRepository> GetPackagesFolderSourceRepositoryAsync() { IVsSolutionManager solutionManager = await _sharedServiceState.SolutionManager.GetValueAsync(); ISettings settings = await ServiceLocator.GetComponentModelServiceAsync<ISettings>(); return _sharedServiceState.SourceRepositoryProvider.CreateRepository( new PackageSource(PackagesFolderPathUtility.GetPackagesFolderPath(solutionManager, settings)), FeedType.FileSystemPackagesConfig); }
public async Task <NuGetProject> UpdateNuGetProjectToPackageRef(NuGetProject oldProject) { #if VS14 // do nothing for VS 2015 and simply return the existing NuGetProject if (NuGetProjectUpdated != null) { NuGetProjectUpdated(this, new NuGetProjectEventArgs(oldProject)); } return(await Task.FromResult(oldProject)); #else if (oldProject == null) { throw new ArgumentException( Strings.Argument_Cannot_Be_Null_Or_Empty, nameof(oldProject)); } var projectName = GetNuGetProjectSafeName(oldProject); var dteProject = GetDTEProject(projectName); ProjectNames oldEnvDTEProjectName; _projectSystemCache.TryGetProjectNames(projectName, out oldEnvDTEProjectName); RemoveEnvDTEProjectFromCache(projectName); var nuGetProject = await NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() => { await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var settings = ServiceLocator.GetInstance <ISettings>(); var context = new ProjectSystemProviderContext( EmptyNuGetProjectContext, () => PackagesFolderPathUtility.GetPackagesFolderPath(this, settings)); return(new LegacyCSProjPackageReferenceProject( new EnvDTEProjectAdapter(dteProject), VsHierarchyUtility.GetProjectId(dteProject))); }); var added = _projectSystemCache.AddProject(oldEnvDTEProjectName, dteProject, nuGetProject); if (DefaultNuGetProjectName == null) { DefaultNuGetProjectName = projectName; } if (NuGetProjectUpdated != null) { NuGetProjectUpdated(this, new NuGetProjectEventArgs(nuGetProject)); } return(nuGetProject); #endif }
public PackageManagementPathResolver(IMonoDevelopSolutionManager solutionManager) { var pathContext = NuGetPathContext.Create(solutionManager.Settings); pathResolver = new FallbackPackagePathResolver(pathContext); globalPackagesFolderResolver = new VersionFolderPathResolver(pathContext.UserPackageFolder); string packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(solutionManager, solutionManager.Settings); folderNuGetProject = new FolderNuGetProject(packagesFolderPath); }
public async Task InstallingPackageShouldCreateLockFile_CustomLockFileName() { // Arrange using (var packageSource = TestDirectory.Create()) using (var testSolutionManager = new TestSolutionManager()) { var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider( new List <PackageSource>() { new PackageSource(packageSource.Path) }); var testSettings = NullSettings.Instance; var token = CancellationToken.None; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var packageContext = new SimpleTestPackageContext("packageA"); packageContext.AddFile("lib/net45/a.dll"); SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource); var msBuildNuGetProject = testSolutionManager.AddNewMSBuildProject(); var msBuildNuGetProjectSystem = msBuildNuGetProject.ProjectSystem as TestMSBuildNuGetProjectSystem; msBuildNuGetProjectSystem.SetPropertyValue("RestorePackagesWithLockFile", "true"); msBuildNuGetProjectSystem.SetPropertyValue("NuGetLockFilePath", "my.lock.json"); var packagesConfigPath = msBuildNuGetProject.PackagesConfigNuGetProject.FullPath; var packagesLockPath = packagesConfigPath.Replace("packages.config", "my.lock.json"); var packageIdentity = packageContext.Identity; // Pre-Assert // Check that the packages.lock.json file does not exist Assert.False(File.Exists(packagesLockPath)); // Act await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity, new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert // Check that the packages.lock.json file exists after the installation Assert.True(File.Exists(packagesLockPath)); Assert.True(msBuildNuGetProjectSystem.FileExistsInProject("my.lock.json")); // Check the number of target frameworks and dependencies in the lock file var lockFile = PackagesLockFileFormat.Read(packagesLockPath); Assert.Equal(1, lockFile.Targets.Count); Assert.Equal(1, lockFile.Targets[0].Dependencies.Count); } }
public bool TryCreateSolutionContext(string solutionDirectory, out IVsPathContext2 outputPathContext) { if (solutionDirectory == null) { throw new ArgumentNullException(nameof(solutionDirectory)); } var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(solutionDirectory, _settings.Value); outputPathContext = GetSolutionPathContext(packagesFolderPath); return(outputPathContext != null); }
private NuGetProject CreateNuGetProject(IVsProjectAdapter project, INuGetProjectContext projectContext = null) { var context = new ProjectProviderContext( projectContext ?? EmptyNuGetProjectContext, () => PackagesFolderPathUtility.GetPackagesFolderPath(this, _settings.Value)); if (_projectSystemFactory.TryCreateNuGetProject(project, context, out var result)) { return(result); } return(null); }
public static FilePath GetPackagesFolderPath(this NuGetProject project, IMonoDevelopSolutionManager solutionManager) { if (project is ProjectJsonBuildIntegratedNuGetProject) { string globalPackagesPath = SettingsUtility.GetGlobalPackagesFolder(solutionManager.Settings); return(new FilePath(globalPackagesPath).FullPath); } string path = PackagesFolderPathUtility.GetPackagesFolderPath(solutionManager, solutionManager.Settings); return(new FilePath(path).FullPath); }
public static FilePath GetPackagesFolderPath(this NuGetProject project, IMonoDevelopSolutionManager solutionManager) { if (project is BuildIntegratedProjectSystem) { string globalPackagesPath = BuildIntegratedProjectUtility.GetEffectiveGlobalPackagesFolder( solutionManager.SolutionDirectory, solutionManager.Settings); return(new FilePath(globalPackagesPath).FullPath); } string path = PackagesFolderPathUtility.GetPackagesFolderPath(solutionManager, solutionManager.Settings); return(new FilePath(path).FullPath); }
public async Task UnzippedPackageInstall_Basic() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); using (var testSolutionManager = new TestSolutionManager(true)) using (var randomPackagesConfigFolderPath = TestDirectory.Create()) { var testSettings = new Configuration.NullSettings(); var deleteOnRestartManager = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config"); var token = CancellationToken.None; var projectTargetFramework = NuGetFramework.Parse("net45"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigFolderPath); var packageIdentity = NoDependencyLibPackages[0]; // Pre-Assert // Check that the packages.config file does not exist Assert.False(File.Exists(randomPackagesConfigPath)); // Check that there are no packages returned by PackagesConfigProject var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(0, packagesInPackagesConfig.Count); Assert.Equal(0, msBuildNuGetProjectSystem.References.Count); // Act await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity, new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert // Check that the packages.config file exists after the installation Assert.True(File.Exists(randomPackagesConfigPath)); // Check the number of packages and packages returned by PackagesConfigProject after the installation packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(1, packagesInPackagesConfig.Count); Assert.Equal(packageIdentity, packagesInPackagesConfig[0].PackageIdentity); Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework); } }
public NuGetProject CreateNuGetProject(DotNetProject project, INuGetProjectContext context) { Runtime.AssertMainThread(); var nugetAwareProject = project as INuGetAwareProject; if (nugetAwareProject != null) { return(nugetAwareProject.CreateNuGetProject()); } NuGetProject dotNetCoreProject = DotNetCoreNuGetProject.Create(project); if (dotNetCoreProject != null) { return(dotNetCoreProject); } NuGetProject packageReferenceProject = PackageReferenceNuGetProject.Create(project); if (packageReferenceProject != null) { return(packageReferenceProject); } var projectSystem = new MonoDevelopMSBuildNuGetProjectSystem(project, context); string projectJsonPath = ProjectJsonPathUtilities.GetProjectConfigPath(project.BaseDirectory, project.Name); if (File.Exists(projectJsonPath)) { return(new ProjectJsonBuildIntegratedNuGetProject( projectJsonPath, project.FileName, project, settings)); } string baseDirectory = GetBaseDirectory(project); string folderNuGetProjectFullPath = PackagesFolderPathUtility.GetPackagesFolderPath(baseDirectory, settings); string packagesConfigFolderPath = project.BaseDirectory; return(new MonoDevelopMSBuildNuGetProject( projectSystem, folderNuGetProjectFullPath, packagesConfigFolderPath)); }
public bool TryCreateSolutionContext(out IVsPathContext2 outputPathContext) { try { var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(_solutionManager.Value, _settings.Value); outputPathContext = new VsPathContext(NuGetPathContext.Create(_settings.Value), _telemetryProvider, packagesFolderPath); return(outputPathContext != null); } catch (Exception exception) { _telemetryProvider.PostFault(exception, typeof(VsPathContextProvider).FullName); throw; } }
public async Task DoNotCreateLockFileWhenFeatureDisabled() { // Arrange using (var packageSource = TestDirectory.Create()) using (var testSolutionManager = new TestSolutionManager()) { var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider( new List <PackageSource>() { new PackageSource(packageSource.Path) }); var testSettings = NullSettings.Instance; var token = CancellationToken.None; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var packageContext = new SimpleTestPackageContext("packageA"); packageContext.AddFile("lib/net45/a.dll"); SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource); var msBuildNuGetProject = testSolutionManager.AddNewMSBuildProject(); var msBuildNuGetProjectSystem = msBuildNuGetProject.ProjectSystem as TestMSBuildNuGetProjectSystem; msBuildNuGetProjectSystem.SetPropertyValue("RestorePackagesWithLockFile", "false"); var packagesConfigPath = msBuildNuGetProject.PackagesConfigNuGetProject.FullPath; var packagesLockPath = packagesConfigPath.Replace("packages.config", "packages.lock.json"); var packageIdentity = packageContext.Identity; // Pre-Assert // Check that the packages.lock.json file does not exist Assert.False(File.Exists(packagesLockPath)); // Act await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity, new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert // Check that the packages.lock.json still does not exist after the installation Assert.False(File.Exists(packagesLockPath)); } }
private NuGetProject CreateNuGetProject(Project envDTEProject, INuGetProjectContext projectContext = null) { var settings = ServiceLocator.GetInstance <ISettings>(); var context = new ProjectSystemProviderContext( projectContext ?? EmptyNuGetProjectContext, () => PackagesFolderPathUtility.GetPackagesFolderPath(this, settings)); NuGetProject result; if (_projectSystemFactory.TryCreateNuGetProject(envDTEProject, context, out result)) { return(result); } return(null); }
/// <summary> /// Finds the NuGetProject from a DTE project /// </summary> public static NuGetProject GetProject(ISolutionManager solutionManager, Project project, VSAPIProjectContext projectContext = null) { if (solutionManager == null) { throw new ArgumentNullException("solution"); } var projectSafeName = EnvDTEProjectUtility.GetCustomUniqueName(project); NuGetProject nuGetProject = solutionManager.GetNuGetProject(projectSafeName); var settings = ServiceLocator.GetInstance <ISettings>(); // if the project does not exist in the solution (this is true for new templates) create it manually if (nuGetProject == null) { VSNuGetProjectFactory factory = new VSNuGetProjectFactory(() => PackagesFolderPathUtility.GetPackagesFolderPath(solutionManager, settings)); nuGetProject = factory.CreateNuGetProject(project, projectContext); } return(nuGetProject); }
public async Task <NuGetProject> TryCreateNuGetProjectAsync(IProjectAdapter projectAdapter, ProjectProviderContext context, IProjectRestoreService projectRestoreService, bool forceProjectType) { var projectSystem = await MSBuildNuGetProjectSystemFactory.CreateMSBuildNuGetProjectSystemAsync(projectAdapter, context.ProjectContext); await projectSystem.InitializeAsync(); var projectServices = new VsMSBuildProjectSystemServices(new MSBuildProjectSystem(projectAdapter, context.ProjectContext), projectAdapter); var solutionDirectory = projectAdapter.SolutionDirectory ?? projectAdapter.ProjectDirectory; var nuGetSettings = Settings.LoadDefaultSettings(solutionDirectory); var folderNuGetProjectFullPath = PackagesFolderPathUtility.GetPackagesFolderPath(solutionDirectory, nuGetSettings); var packagesConfigFolderPath = projectAdapter.ProjectDirectory; return(new NetFrameworkNuGetProject(projectSystem, folderNuGetProjectFullPath, packagesConfigFolderPath, projectServices)); }
public bool TryCreateSolutionContext(string solutionDirectory, out IVsPathContext2 outputPathContext) { if (solutionDirectory == null) { throw new ArgumentNullException(nameof(solutionDirectory)); } try { var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(solutionDirectory, _settings.Value); outputPathContext = new VsPathContext(NuGetPathContext.Create(_settings.Value), _telemetryProvider, packagesFolderPath); return(outputPathContext != null); } catch (Exception exception) { _telemetryProvider.PostFault(exception, typeof(VsPathContextProvider).FullName); throw; } }
private async Task <IVsPathContext> GetPathContextForPackagesConfigAsync( IVsProjectAdapter vsProjectAdapter, CancellationToken token) { await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var props = new Dictionary <string, object>(); props.Add(NuGetProjectMetadataKeys.Name, Path.GetFileNameWithoutExtension(vsProjectAdapter.FullProjectPath)); props.Add(NuGetProjectMetadataKeys.TargetFramework, await vsProjectAdapter.GetTargetFrameworkAsync()); var packagesProject = new PackagesConfigNuGetProject(vsProjectAdapter.ProjectDirectory, props); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(_solutionManager.Value, _settings.Value); var folderProject = new FolderNuGetProject(packagesFolderPath); // switch to a background thread to process packages data await TaskScheduler.Default; var packageReferences = await packagesProject.GetInstalledPackagesAsync(token); var trie = new PathLookupTrie <string>(); foreach (var pid in packageReferences.Select(pr => pr.PackageIdentity)) { var packageInstallPath = folderProject.GetInstalledPath(pid); if (string.IsNullOrEmpty(packageInstallPath)) { throw new KeyNotFoundException(string.Format(CultureInfo.CurrentCulture, VsResources.PathContext_PackageDirectoryNotFound, pid)); } trie[packageInstallPath] = packageInstallPath; } var pathContext = GetSolutionPathContext(); return(new VsIndexedPathContext( pathContext.UserPackageFolder, pathContext.FallbackPackageFolders.Cast <string>(), trie)); }
public async Task <NuGetProject> UpgradeProjectToPackageReferenceAsync(NuGetProject oldProject) { #if VS14 // do nothing for VS 2015 and simply return the existing NuGetProject if (NuGetProjectUpdated != null) { NuGetProjectUpdated(this, new NuGetProjectEventArgs(oldProject)); } return(await Task.FromResult(oldProject)); #else Assumes.Present(oldProject); var projectName = GetNuGetProjectSafeName(oldProject); var vsProjectAdapter = GetVsProjectAdapter(projectName); _projectSystemCache.TryGetProjectNames(projectName, out var projectNames); RemoveVsProjectAdapterFromCache(projectName); var context = new ProjectProviderContext( EmptyNuGetProjectContext, () => PackagesFolderPathUtility.GetPackagesFolderPath(this, _settings.Value)); var nuGetProject = await _projectSystemFactory.CreateNuGetProjectAsync <LegacyPackageReferenceProject>( vsProjectAdapter, context); var added = _projectSystemCache.AddProject(projectNames, vsProjectAdapter, nuGetProject); if (DefaultNuGetProjectName == null) { DefaultNuGetProjectName = projectName; } NuGetProjectUpdated?.Invoke(this, new NuGetProjectEventArgs(nuGetProject)); return(nuGetProject); #endif }
private string GetPackagesFolderPath() { if (!String.IsNullOrEmpty(PackagesDirectory)) { return(PackagesDirectory); } // Packages folder needs to be inferred from SolutionFilePath or SolutionDirectory var effectiveSolutionDirectory = GetEffectiveSolutionDirectory(); if (!String.IsNullOrEmpty(effectiveSolutionDirectory)) { ReadSettings(effectiveSolutionDirectory); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(effectiveSolutionDirectory, Settings); if (!String.IsNullOrEmpty(packagesFolderPath)) { return(packagesFolderPath); } } throw new InvalidOperationException(LocalizedResourceManager.GetString("RestoreCommandCannotDeterminePackagesFolder")); }