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"));
}
