/// <summary>
/// Initialize a new instance of <see cref="NugetStore"/>.
/// </summary>
/// <param name="oldRootDirectory">The location of the Nuget store.</param>
public NugetStore(string oldRootDirectory)
{
// Used only for versions before 3.0
this.oldRootDirectory = oldRootDirectory;
settings = NuGet.Configuration.Settings.LoadDefaultSettings(null);
// Remove obsolete sources
RemoveDeletedSources(settings, "Xenko Dev");
// Note the space: we want to keep "Stride Dev" but not "Stride Dev {PATH}\bin\packages" anymore
RemoveSources(settings, "Stride Dev ");
settings.SaveToDisk();
InstallPath = SettingsUtility.GetGlobalPackagesFolder(settings);
var pathContext = NuGetPathContext.Create(settings);
InstalledPathResolver = new FallbackPackagePathResolver(pathContext.UserPackageFolder, oldRootDirectory != null ? pathContext.FallbackPackageFolders.Concat(new[] { oldRootDirectory }) : pathContext.FallbackPackageFolders);
var packageSourceProvider = new PackageSourceProvider(settings);
var availableSources = packageSourceProvider.LoadPackageSources().Where(source => source.IsEnabled);
var packageSources = new List <PackageSource>();
packageSources.AddRange(availableSources);
PackageSources = packageSources;
// Setup source provider as a V3 only.
sourceRepositoryProvider = new NugetSourceRepositoryProvider(packageSourceProvider, this);
}
//returns the lock file, if it changed
async Task <string> RestorePackagesInternal(
BuildIntegratedNuGetProject project,
CancellationToken cancellationToken)
{
var nugetPaths = NuGetPathContext.Create(settings);
RestoreResult restoreResult = await BuildIntegratedRestoreUtility.RestoreAsync(
project,
context,
sourceRepositories,
nugetPaths.UserPackageFolder,
nugetPaths.FallbackPackageFolders,
cancellationToken);
if (restoreResult.Success)
{
if (!object.Equals(restoreResult.LockFile, restoreResult.PreviousLockFile))
{
return(restoreResult.LockFilePath);
}
}
else
{
ReportRestoreError(restoreResult);
}
return(null);
}
private async Task <Uri> GetNugetUri(CancellationToken cancellationToken)
{
var settings = Settings.LoadDefaultSettings(null);
var packageSourceProvider = new PackageSourceProvider(settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, FactoryExtensionsV3.GetCoreV3(Repository.Provider));
var package = new PackageIdentity("PostgreSql.Binaries.Lite", NuGetVersion.Parse(_pgVersion));
var pathContext = NuGetPathContext.Create(settings);
var localSources = new List <string>();
localSources.Add(pathContext.UserPackageFolder);
localSources.AddRange(pathContext.FallbackPackageFolders);
using (var cacheContext = new SourceCacheContext())
{
var repositories = localSources
.Select(path => sourceRepositoryProvider.CreateRepository(new PackageSource(path), FeedType.FileSystemV3))
.Concat(sourceRepositoryProvider.GetRepositories());
foreach (var sourceRepository in repositories)
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
package, NuGetFramework.AnyFramework, cacheContext, NullLogger.Instance, cancellationToken);
if (dependencyInfo != null)
{
return(dependencyInfo.DownloadUri);
}
}
}
throw new Exception("Could not find PostgreSql.Binaries.Lite package");
}
public void GetDescriptionShouldNotModifyTarget()
{
var provider = new PackageDependencyProvider(
NuGetPathContext.Create("/foo/packages"),
new FrameworkReferenceResolver("/foo/references"));
var package = new LockFilePackageLibrary();
package.Name = "Something";
package.Version = NuGetVersion.Parse("1.0.0");
package.Files.Add("lib/dotnet/_._");
package.Files.Add("runtimes/any/native/Microsoft.CSharp.CurrentVersion.targets");
var target = new LockFileTargetLibrary();
target.Name = "Something";
target.Version = package.Version;
target.RuntimeAssemblies.Add("lib/dotnet/_._");
target.CompileTimeAssemblies.Add("lib/dotnet/_._");
target.NativeLibraries.Add("runtimes/any/native/Microsoft.CSharp.CurrentVersion.targets");
var p1 = provider.GetDescription(NuGetFramework.Parse("netcoreapp1.0"), package, target);
var p2 = provider.GetDescription(NuGetFramework.Parse("netcoreapp1.0"), package, target);
Assert.True(p1.Compatible);
Assert.True(p2.Compatible);
Assert.Empty(p1.CompileTimeAssemblies);
Assert.Empty(p1.RuntimeAssemblies);
Assert.Empty(p2.CompileTimeAssemblies);
Assert.Empty(p2.RuntimeAssemblies);
}
public void HasCompileTimePlaceholderChecksAllCompileTimeAssets()
{
var provider = new PackageDependencyProvider(
NuGetPathContext.Create("/foo/packages"),
new FrameworkReferenceResolver("/foo/references"));
var package = new LockFilePackageLibrary();
package.Name = "Something";
package.Version = NuGetVersion.Parse("1.0.0");
package.Files.Add("lib/net46/_._");
package.Files.Add("lib/net46/Something.dll");
var target = new LockFileTargetLibrary();
target.Name = "Something";
target.Version = package.Version;
target.RuntimeAssemblies.Add("lib/net46/_._");
target.RuntimeAssemblies.Add("lib/net46/Something.dll");
target.CompileTimeAssemblies.Add("lib/net46/_._");
target.CompileTimeAssemblies.Add("lib/net46/Something.dll");
var p1 = provider.GetDescription(NuGetFramework.Parse("net46"), package, target);
Assert.False(p1.HasCompileTimePlaceholder);
Assert.Equal(1, p1.CompileTimeAssemblies.Count());
Assert.Equal(1, p1.RuntimeAssemblies.Count());
Assert.Equal("lib/net46/Something.dll", p1.CompileTimeAssemblies.First().Path);
Assert.Equal("lib/net46/Something.dll", p1.RuntimeAssemblies.First().Path);
}
public void GetDescriptionShouldGenerateHashFileName()
{
// Arrange
var provider = new PackageDependencyProvider(
NuGetPathContext.Create("/foo/packages"),
new FrameworkReferenceResolver("/foo/references"));
var package = new LockFilePackageLibrary();
package.Name = "Something";
package.Version = NuGetVersion.Parse("1.0.0-Beta");
package.Files.Add("lib/dotnet/_._");
package.Files.Add("runtimes/any/native/Microsoft.CSharp.CurrentVersion.targets");
package.Path = "SomePath";
var target = new LockFileTargetLibrary();
target.Name = "Something";
target.Version = package.Version;
target.RuntimeAssemblies.Add("lib/dotnet/_._");
target.CompileTimeAssemblies.Add("lib/dotnet/_._");
target.NativeLibraries.Add("runtimes/any/native/Microsoft.CSharp.CurrentVersion.targets");
// Act
var p = provider.GetDescription(NuGetFramework.Parse("netcoreapp1.0"), package, target);
// Assert
p.PackageLibrary.Path.Should().Be("SomePath");
p.HashPath.Should().Be("something.1.0.0-beta.nupkg.sha512");
}
private static FscCommandSpec ResolveFsc(List <string> fscArgs, string temp)
{
var nugetPackagesRoot = NuGetPathContext.Create(Directory.GetCurrentDirectory())?.UserPackageFolder;
var depsFile = Path.Combine(AppContext.BaseDirectory, "dotnet-compile-fsc" + FileNameSuffixes.DepsJson);
var depsJsonCommandResolver = new DepsJsonCommandResolver(nugetPackagesRoot);
var dependencyContext = depsJsonCommandResolver.LoadDependencyContextFromFile(depsFile);
var fscPath = depsJsonCommandResolver.GetCommandPathFromDependencyContext("fsc", dependencyContext);
var commandResolverArgs = new CommandResolverArguments()
{
CommandName = "fsc",
CommandArguments = fscArgs,
DepsJsonFile = depsFile
};
var fscCommandSpec = depsJsonCommandResolver.Resolve(commandResolverArgs);
var runtimeConfigFile = Path.Combine(
Path.GetDirectoryName(typeof(CompileFscCommand).GetTypeInfo().Assembly.Location)
, "dotnet-compile-fsc" + FileNameSuffixes.RuntimeConfigJson);
CopyRuntimeConfigForFscExe(runtimeConfigFile, "fsc", depsFile, nugetPackagesRoot, fscPath);
return(new FscCommandSpec
{
Spec = fscCommandSpec,
FscExeDir = Path.GetDirectoryName(fscPath),
FscExeFile = fscPath
});
}
/// <summary>
/// Initialize a new instance of <see cref="NugetStore"/>.
/// </summary>
/// <param name="oldRootDirectory">The location of the Nuget store.</param>
public NugetStore(string oldRootDirectory)
{
// Used only for versions before 3.0
this.oldRootDirectory = oldRootDirectory;
settings = NuGet.Configuration.Settings.LoadDefaultSettings(null);
// Add dev source
CheckPackageSource("Xenko", DefaultPackageSource);
InstallPath = SettingsUtility.GetGlobalPackagesFolder(settings);
var pathContext = NuGetPathContext.Create(settings);
InstalledPathResolver = new FallbackPackagePathResolver(pathContext.UserPackageFolder, oldRootDirectory != null ? pathContext.FallbackPackageFolders.Concat(new[] { oldRootDirectory }) : pathContext.FallbackPackageFolders);
var packageSourceProvider = new PackageSourceProvider(settings);
var availableSources = packageSourceProvider.LoadPackageSources().Where(source => source.IsEnabled);
var packageSources = new List <PackageSource>();
packageSources.AddRange(availableSources);
PackageSources = packageSources;
// Setup source provider as a V3 only.
sourceRepositoryProvider = new NugetSourceRepositoryProvider(packageSourceProvider, this);
}
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;
}
}
private string GetPackageInstalledPath(PackageIdentity packageIdentity)
{
var nugetPaths = NuGetPathContext.Create(Settings);
var fallbackResolver = new FallbackPackagePathResolver(nugetPaths);
// Verify the package exists and return the path. Return null otherwise.
return(fallbackResolver.GetPackageDirectory(packageIdentity.Id, packageIdentity.Version));
}
public bool TryCreateSolutionContext(out IVsPathContext2 outputPathContext)
{
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(_solutionManager.Value, _settings.Value);
outputPathContext = new VsPathContext(NuGetPathContext.Create(_settings.Value), packagesFolderPath);
return(outputPathContext != null);
}
private CommandSpec ResolveCommandSpecFromToolLibrary(
SingleProjectInfo toolLibraryRange,
string commandName,
IEnumerable <string> args,
LockFile lockFile,
IProject project)
{
Reporter.Verbose.WriteLine($"projecttoolscommandresolver: Attempting to resolve command spec from tool {toolLibraryRange.Name}");
var nuGetPathContext = NuGetPathContext.Create(project.ProjectRoot);
var nugetPackagesRoot = nuGetPathContext.UserPackageFolder;
Reporter.Verbose.WriteLine($"projecttoolscommandresolver: nuget packages root:\n{nugetPackagesRoot}");
var toolLockFile = GetToolLockFile(toolLibraryRange, nugetPackagesRoot);
Reporter.Verbose.WriteLine($"projecttoolscommandresolver: found tool lockfile at : {toolLockFile.Path}");
var toolLibrary = toolLockFile.Targets
.FirstOrDefault(
t => t.TargetFramework.GetShortFolderName().Equals(s_toolPackageFramework.GetShortFolderName()))
?.Libraries.FirstOrDefault(l => l.Name == toolLibraryRange.Name);
if (toolLibrary == null)
{
Reporter.Verbose.WriteLine($"projecttoolscommandresolver: library not found in lock file.");
return(null);
}
var depsFileRoot = Path.GetDirectoryName(toolLockFile.Path);
var depsFilePath = GetToolDepsFilePath(toolLibraryRange, toolLockFile, depsFileRoot);
var normalizedNugetPackagesRoot = PathUtility.EnsureNoTrailingDirectorySeparator(nugetPackagesRoot);
Reporter.Verbose.WriteLine($"projecttoolscommandresolver: attempting to create commandspec");
var commandSpec = _packagedCommandSpecFactory.CreateCommandSpecFromLibrary(
toolLibrary,
commandName,
args,
_allowedCommandExtensions,
normalizedNugetPackagesRoot,
s_commandResolutionStrategy,
depsFilePath,
null);
if (commandSpec == null)
{
Reporter.Verbose.WriteLine($"projecttoolscommandresolver: commandSpec is null.");
}
commandSpec?.AddEnvironmentVariablesFromProject(project);
return(commandSpec);
}
public IEnumerable <IVsPackageMetadata> GetInstalledPackages()
{
var packages = new HashSet <IVsPackageMetadata>(new VsPackageMetadataComparer());
return(NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate
{
// Calls may occur in the template wizard before the solution is actually created,
// in that case return no projects
if (_solutionManager != null &&
!string.IsNullOrEmpty(_solutionManager.SolutionDirectory))
{
InitializePackageManagerAndPackageFolderPath();
var pathContext = NuGetPathContext.Create(_settings);
var pathResolver = new FallbackPackagePathResolver(pathContext);
var globalPackagesFolderResolver = new VersionFolderPathResolver(pathContext.UserPackageFolder);
foreach (var project in _solutionManager.GetNuGetProjects())
{
var installedPackages = await project.GetInstalledPackagesAsync(CancellationToken.None);
foreach (var package in installedPackages)
{
var identity = package.PackageIdentity;
if (!identity.HasVersion)
{
// Currently we are not supporting floating versions
// because of that we will skip this package
continue;
}
// find packages using the solution level packages folder
string installPath;
if (project is INuGetIntegratedProject)
{
installPath = pathResolver.GetPackageDirectory(identity.Id, identity.Version) ??
globalPackagesFolderResolver.GetInstallPath(identity.Id, identity.Version);
}
else
{
installPath = _packageManager
.PackagesFolderNuGetProject
.GetInstalledPath(identity);
}
var metadata = new VsPackageMetadata(package.PackageIdentity, installPath);
packages.Add(metadata);
}
}
}
return packages;
}));
}
/// <summary>
/// No solution manager provided so only global packages cache will be considered.
/// </summary>
public PackageManagementPathResolver()
{
var settings = SettingsLoader.LoadDefaultSettings();
var pathContext = NuGetPathContext.Create(settings);
pathResolver = new FallbackPackagePathResolver(pathContext);
globalPackagesFolderResolver = new VersionFolderPathResolver(pathContext.UserPackageFolder);
folderNuGetProject = new FolderNuGetProject(pathContext.UserPackageFolder);
}
public VsPathContext(NuGetPathContext pathContext)
{
if (pathContext == null)
{
throw new ArgumentNullException(nameof(pathContext));
}
UserPackageFolder = pathContext.UserPackageFolder;
FallbackPackageFolders = pathContext.FallbackPackageFolders;
}
async Task CollectPackagesForBuildIntegratedProjectAsync(
BuildIntegratedNuGetProject project,
ISet <PackageIdentity> finishedPackages,
IList <PackageItem> installedPackages,
CancellationToken token)
{
token.ThrowIfCancellationRequested();
var lockFile = await getLockFileOrNullAsync(project);
if (lockFile == null)
{
return;
}
if (lockFile.Libraries == null ||
lockFile.Libraries.Count == 0)
{
return;
}
FallbackPackagePathResolver fppr;
if ((lockFile?.PackageFolders?.Count ?? 0) != 0)
{
// The user packages folder is always the first package folder. Subsequent package folders are always
// fallback package folders.
var packageFolders = lockFile
.PackageFolders
.Select(lockFileItem => lockFileItem.Path);
var userPackageFolder = packageFolders.First();
var fallbackPackageFolders = packageFolders.Skip(1);
fppr = new FallbackPackagePathResolver(userPackageFolder, fallbackPackageFolders);
}
else
{
var pathContext = NuGetPathContext.Create(settings);
fppr = new FallbackPackagePathResolver(pathContext);
}
foreach (var package in BuildIntegratedProjectUtility.GetOrderedLockFilePackageDependencies(lockFile))
{
if (!finishedPackages.Contains(package))
{
var installPath = fppr.GetPackageDirectory(package.Id, package.Version);
if (!string.IsNullOrEmpty(installPath))
{
installedPackages.Add(new PackageItem(package, installPath));
finishedPackages.Add(package);
}
}
}
}
public async Task RunToolWithCreateConfigVerifySuccess()
{
using (var testContext = new SleetTestContext())
{
var dir = Path.Combine(testContext.Root, "project");
Directory.CreateDirectory(dir);
var dotnetExe = GetDotnetPath();
var exeFile = new FileInfo(dotnetExe);
var nupkgsFolder = Path.Combine(exeFile.Directory.Parent.FullName, "artifacts", "nupkgs");
var sleetNupkg = LocalFolderUtility.GetPackagesV2(nupkgsFolder, "Sleet", NullLogger.Instance)
.OrderByDescending(e => e.Nuspec.GetVersion())
.First();
var sleetVersion = sleetNupkg.Nuspec.GetVersion().ToNormalizedString();
var result = await CmdRunner.RunAsync(dotnetExe, dir, "new classlib");
result.Success.Should().BeTrue();
var projectPath = Path.Combine(dir, "project.csproj");
var pathContext = NuGetPathContext.Create(dir);
var pathResolver = new FallbackPackagePathResolver(pathContext);
// Delete restore assets file
var toolInstallPath = Path.Combine(pathContext.UserPackageFolder, ".tools", "sleet");
Delete(new DirectoryInfo(toolInstallPath));
// Delete the tool package itself if it exists
var toolPackagePath = Path.Combine(pathContext.UserPackageFolder, "sleet", sleetVersion);
Delete(new DirectoryInfo(toolPackagePath));
// Add a reference to the tool
var xml = XDocument.Load(projectPath);
xml.Root.Add(new XElement(XName.Get("ItemGroup"),
new XElement(XName.Get("DotNetCliToolReference"),
new XAttribute("Include", "Sleet"),
new XAttribute("Version", sleetVersion))));
xml.Save(projectPath);
// Restore the tool
result = await CmdRunner.RunAsync(dotnetExe, dir, $"restore --source {nupkgsFolder}");
result.Success.Should().BeTrue();
// Run the tool
result = await CmdRunner.RunAsync(dotnetExe, dir, $"sleet createconfig");
result.Success.Should().BeTrue();
File.Exists(Path.Combine(dir, "sleet.json")).Should().BeTrue();
}
}
/// <summary>
/// The base constructor for a feed
/// </summary>
/// <param name="feedLocation">The feed location</param>
/// <param name="factory">Add a loggerfactory for logging stuff</param>
internal NuGetServer(string feedLocation, ILoggerFactory factory = null)
{
FeedLocation = feedLocation;
Source = Repository.Factory.GetCoreV3(feedLocation);
Logger = new NuGetLogger(factory?.CreateLogger <NuGetLogger>());
NuGetSettings = Settings.LoadDefaultSettings(Directory.GetCurrentDirectory());
TempDownloadLocation = NuGetPathContext.Create(NuGetSettings).UserPackageFolder;
}
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);
}
private async Task <IVsPathContext> TryCreateUserWideContextAsync()
{
// It's acceptable to cache these results cause currently:
// 1. We do not reload configs
// 2. There is no way to edit gpf/fallback folders through the PM UI.
var settings = await _userWideSettings.GetValueAsync();
var outputPathContext = new VsPathContext(NuGetPathContext.Create(settings), _telemetryProvider);
return(outputPathContext);
}
public Task <bool> IsRestoreRequired(BuildIntegratedNuGetProject project)
{
var nugetPaths = NuGetPathContext.Create(settings);
var packageFolderPaths = new List <string>();
packageFolderPaths.Add(nugetPaths.UserPackageFolder);
packageFolderPaths.AddRange(nugetPaths.FallbackPackageFolders);
var projects = new BuildIntegratedNuGetProject[] { project };
return(BuildIntegratedRestoreUtility.IsRestoreRequired(projects, packageFolderPaths, context));
}
/// <summary>
/// Initialize NugetStore using <paramref name="rootDirectory"/> as location of the local copies,
/// and a configuration file <paramref name="configFile"/> as well as an override configuration
/// file <paramref name="overrideFile"/> where all settings of <paramref name="overrideFile"/> also
/// presents in <paramref name="configFile"/> take precedence.
/// </summary>
/// <param name="rootDirectory">The location of the Nuget store.</param>
public NugetStore(string rootDirectory, string configFile = DefaultConfig)
{
RootDirectory = rootDirectory ?? throw new ArgumentNullException(nameof(rootDirectory));
settings = NuGet.Configuration.Settings.LoadDefaultSettings(rootDirectory);
// Add dev source
Directory.CreateDirectory(Environment.ExpandEnvironmentVariables(DevSource));
CheckPackageSource("Xenko Dev", DevSource);
CheckPackageSource("Xenko", DefaultPackageSource);
// Override file does not exist, fallback to default config file
var configFileName = configFile;
var configFilePath = Path.Combine(rootDirectory, configFileName);
if (File.Exists(configFilePath))
{
localSettings = NuGet.Configuration.Settings.LoadDefaultSettings(rootDirectory, configFileName, machineWideSettings: null);
// Replicate packageSources in user config so that NuGet restore can find them as well
foreach (var x in localSettings.GetSettingValues("packageSources", true))
{
CheckPackageSource(x.Key, x.Value);
}
}
InstallPath = SettingsUtility.GetGlobalPackagesFolder(settings);
var pathContext = NuGetPathContext.Create(settings);
InstalledPathResolver = new FallbackPackagePathResolver(pathContext);
var packageSourceProvider = new PackageSourceProvider(settings);
var availableSources = packageSourceProvider.LoadPackageSources().Where(source => source.IsEnabled);
var packageSources = new List <PackageSource>();
packageSources.AddRange(availableSources);
PackageSources = packageSources;
// Setup source provider as a V3 only.
sourceRepositoryProvider = new NugetSourceRepositoryProvider(packageSourceProvider, this);
manager = new NuGetPackageManager(sourceRepositoryProvider, settings, InstallPath);
// Override PackagePathResolver
// Workaround for https://github.com/NuGet/Home/issues/6639
manager.PackagesFolderNuGetProject.GetType().GetProperty("PackagePathResolver", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(manager.PackagesFolderNuGetProject, new PackagePathResolverV3(InstallPath));
// Obsolete (Xenko 2.x support)
InstallPathV2 = Path.Combine(RootDirectory, DefaultGamePackagesDirectory);
managerV2 = new NuGetPackageManager(sourceRepositoryProvider, settings, InstallPathV2);
PathResolverV2 = new PackagePathResolver(InstallPathV2);
}
public bool TryCreateSolutionContext(string solutionDirectory, out IVsPathContext2 outputPathContext)
{
if (solutionDirectory == null)
{
throw new ArgumentNullException(nameof(solutionDirectory));
}
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(solutionDirectory, _settings.Value);
outputPathContext = new VsPathContext(NuGetPathContext.Create(_settings.Value), packagesFolderPath);
return(outputPathContext != null);
}
public Task <bool> IsRestoreRequired(BuildIntegratedNuGetProject project)
{
var pathContext = NuGetPathContext.Create(settings);
var packageFolderPaths = new List <string> ();
packageFolderPaths.Add(pathContext.UserPackageFolder);
packageFolderPaths.AddRange(pathContext.FallbackPackageFolders);
var pathResolvers = packageFolderPaths.Select(path => new VersionFolderPathResolver(path));
var packagesChecked = new HashSet <PackageIdentity> ();
return(project.IsRestoreRequired(pathResolvers, packagesChecked, context));
}
private IVsPathContext2 GetSolutionPathContext(string packagesFolderPath)
{
VsPathContext pathContext = null;
// if solution package folder exists, then set it in VSPathContext
if (!string.IsNullOrEmpty(packagesFolderPath) && Directory.Exists(packagesFolderPath))
{
pathContext = new VsPathContext(NuGetPathContext.Create(_settings.Value), packagesFolderPath);
}
else
{
pathContext = new VsPathContext(NuGetPathContext.Create(_settings.Value));
}
return(pathContext);
}
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 void NuGetPathContext_LoadDefaultSettings()
{
// Arrange
using (var mockBaseDirectory = TestDirectory.Create())
{
var globalFolder = SettingsUtility.GetGlobalPackagesFolder(NullSettings.Instance);
var http = SettingsUtility.GetHttpCacheFolder();
// Act
var pathContext = NuGetPathContext.Create(NullSettings.Instance);
// Assert
Assert.Equal(0, pathContext.FallbackPackageFolders.Count);
Assert.Equal(globalFolder, pathContext.UserPackageFolder);
Assert.Equal(http, pathContext.HttpCacheFolder);
}
}
public async Task <bool> ExecuteInitScriptAsync(PackageIdentity identity)
{
var result = false;
// Reserve the key. We can remove if the package has not been restored.
if (TryMarkVisited(identity, PackageInitPS1State.NotFound))
{
var nugetPaths = NuGetPathContext.Create(Settings);
var fallbackResolver = new FallbackPackagePathResolver(nugetPaths);
var installPath = fallbackResolver.GetPackageDirectory(identity.Id, identity.Version);
if (!string.IsNullOrEmpty(installPath))
{
var scriptPath = Path.Combine(installPath, "tools", PowerShellScripts.Init);
if (File.Exists(scriptPath))
{
// Init.ps1 is present and will be executed.
InitScriptExecutions.TryUpdate(
identity,
PackageInitPS1State.FoundAndExecuted,
PackageInitPS1State.NotFound);
var request = new ScriptExecutionRequest(scriptPath, installPath, identity, project: null);
await ExecuteScriptCoreAsync(request);
result = true;
}
}
else
{
// Package is not restored. Do not cache the results.
PackageInitPS1State dummy;
InitScriptExecutions.TryRemove(identity, out dummy);
result = false;
}
}
else
{
// Key is already present. Simply access its value
result = (InitScriptExecutions[identity] == PackageInitPS1State.FoundAndExecuted);
}
return(result);
}
private void ExecuteInitPs1ForBuildIntegrated(
List <PackageIdentity> sortedGlobalPackages,
HashSet <PackageIdentity> finishedPackages)
{
var nugetPaths = NuGetPathContext.Create(_settings);
var fallbackResolver = new FallbackPackagePathResolver(nugetPaths);
foreach (var package in sortedGlobalPackages)
{
if (finishedPackages.Add(package))
{
// Find the package path across all folders
var pathToPackage = fallbackResolver.GetPackageDirectory(package.Id, package.Version);
ExecuteInitPs1(pathToPackage, package);
}
}
}
private async Task BuildIntegratedProjectRestoreAsync(
BuildIntegratedNuGetProject project,
string solutionDirectory,
List <SourceRepository> enabledSources,
ExternalProjectReferenceContext context,
RestoreCommandProvidersCache providerCache,
CancellationToken token)
{
// Go off the UI thread to perform I/O operations
await TaskScheduler.Default;
var projectName = NuGetProject.GetUniqueNameOrName(project);
var nugetPathContext = NuGetPathContext.Create(Settings);
using (var cacheContext = new SourceCacheContext())
{
providerCache.GetOrCreate(
nugetPathContext.UserPackageFolder,
nugetPathContext.FallbackPackageFolders,
enabledSources,
cacheContext,
context.Logger);
// Pass down the CancellationToken from the dialog
var restoreResult = await BuildIntegratedRestoreUtility.RestoreAsync(project,
context,
enabledSources,
nugetPathContext.UserPackageFolder,
nugetPathContext.FallbackPackageFolders,
token);
if (!restoreResult.Success)
{
// Mark this as having errors
_hasErrors = true;
// Invalidate cached results for the project. This will cause it to restore the next time.
_buildIntegratedCache.Remove(projectName);
await BuildIntegratedProjectReportErrorAsync(projectName, restoreResult, token);
}
}
}
