public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (!libraryRange.IsGacOrFrameworkReference)
{
return null;
}
if (!RuntimeEnvironmentHelper.IsWindows)
{
return null;
}
if (!VersionUtility.IsDesktop(targetFramework))
{
return null;
}
var name = libraryRange.Name;
var version = libraryRange.VersionRange?.MinVersion;
string path;
if (!TryResolvePartialName(libraryRange.GetReferenceAssemblyName(), version, targetFramework, out path))
{
return null;
}
return new LibraryDescription(
libraryRange,
new LibraryIdentity(name, version, isGacOrFrameworkReference: true),
path,
LibraryTypes.GlobalAssemblyCache,
Enumerable.Empty<LibraryDependency>(),
new[] { libraryRange.GetReferenceAssemblyName() },
framework: targetFramework);
}
public Library GetLibrary(LibraryRange libraryRange, NuGetFramework targetFramework)
{
var key = Tuple.Create(targetFramework, libraryRange.Name);
LockFileTargetLibrary library = null;
// Determine if we have a library for this target
if (_targetLibraries.TryGetValue(key, out library) &&
libraryRange.VersionRange.IsBetter(current: null, considering: library.Version))
{
var dependencies = GetDependencies(library, targetFramework);
var description = new Library {
LibraryRange = libraryRange,
Identity = new LibraryIdentity
{
Name = library.Name,
Version = library.Version,
Type = LibraryTypes.Package
},
Resolved = true,
Dependencies = dependencies,
[KnownLibraryProperties.LockFileLibrary] = _libraries[Tuple.Create(library.Name, library.Version)],
[KnownLibraryProperties.LockFileTargetLibrary] = library
};
return description;
}
return null;
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (libraryRange.IsGacOrFrameworkReference)
{
return null;
}
if (!DependencyTargets.SupportsProject(libraryRange.Target))
{
return null;
}
string name = libraryRange.Name;
Runtime.Project project;
// Can't find a project file with the name so bail
if (!_projectResolver.TryResolveProject(name, out project))
{
return null;
}
// This never returns null
var targetFrameworkInfo = project.GetCompatibleTargetFramework(targetFramework);
var dependencies = project.Dependencies.Concat(targetFrameworkInfo.Dependencies).ToList();
return new ProjectDescription(
libraryRange,
project,
dependencies,
Enumerable.Empty<string>(),
targetFrameworkInfo,
resolved: true);
}
public Library GetDescription(LibraryRange libraryRange, NuGetFramework targetFramework)
{
Debug.Assert(SupportsType(libraryRange.TypeConstraint));
var name = libraryRange.Name;
var version = libraryRange.VersionRange?.MinVersion;
string path;
NuGetVersion assemblyVersion;
if (!FrameworkResolver.TryGetAssembly(name, targetFramework, out path, out assemblyVersion))
{
Log.LogWarning($"Unable to resolve requested assembly {libraryRange.Name}");
return null;
}
if (version == null || version == assemblyVersion)
{
return new Library
{
LibraryRange = libraryRange,
Identity = new LibraryIdentity
{
Name = name,
Version = assemblyVersion,
Type = LibraryTypes.Reference
},
Dependencies = Enumerable.Empty<LibraryDependency>(),
[KnownLibraryProperties.AssemblyPath] = path
};
}
return null;
}
public async Task<WalkProviderMatch> FindLibrary(LibraryRange libraryRange, FrameworkName targetFramework, bool includeUnlisted)
{
var results = await _source.FindPackagesByIdAsync(libraryRange.Name);
PackageInfo bestResult = null;
if(!includeUnlisted)
{
results = results.Where(p => p.Listed);
}
foreach (var result in results)
{
if (VersionUtility.ShouldUseConsidering(
current: bestResult?.Version,
considering: result.Version,
ideal: libraryRange.VersionRange))
{
bestResult = result;
}
}
if (bestResult == null)
{
return null;
}
return new WalkProviderMatch
{
Library = new LibraryIdentity(bestResult.Id, bestResult.Version, isGacOrFrameworkReference: false),
Path = bestResult.ContentUri,
Provider = this,
};
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (!DependencyTargets.SupportsPackage(libraryRange.Target))
{
return null;
}
var versionRange = libraryRange.VersionRange;
var package = FindCandidate(libraryRange.Name, versionRange);
if (package != null)
{
var dependencies = GetDependencies(package, targetFramework);
return new LibraryDescription(
libraryRange,
new LibraryIdentity(package.Id, package.Version, isGacOrFrameworkReference: false),
path: null,
type: LibraryTypes.Package,
dependencies: dependencies,
assemblies: null,
framework: null);
}
return null;
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (!libraryRange.IsGacOrFrameworkReference)
{
return null;
}
var name = libraryRange.GetReferenceAssemblyName();
var version = libraryRange.VersionRange?.MinVersion;
string path;
Version assemblyVersion;
if (!FrameworkResolver.TryGetAssembly(name, targetFramework, out path, out assemblyVersion))
{
return null;
}
if (version == null || version.Version == assemblyVersion)
{
return new LibraryDescription(
libraryRange,
new LibraryIdentity(libraryRange.Name, new SemanticVersion(assemblyVersion), isGacOrFrameworkReference: true),
path,
LibraryTypes.ReferenceAssembly,
Enumerable.Empty<LibraryDependency>(),
new[] { name },
framework: targetFramework);
}
return null;
}
public Library GetLibrary(LibraryRange libraryRange, NuGetFramework targetFramework)
{
var package = FindCandidate(libraryRange.Name, libraryRange.VersionRange);
if (package != null)
{
NuspecReader nuspecReader = null;
using (var stream = File.OpenRead(package.ManifestPath))
{
nuspecReader = new NuspecReader(stream);
}
var description = new Library
{
LibraryRange = libraryRange,
Identity = new LibraryIdentity
{
Name = package.Id,
Version = package.Version,
Type = LibraryTypes.Package
},
Path = package.ManifestPath,
Dependencies = GetDependencies(nuspecReader, targetFramework)
};
description.Items["package"] = package;
description.Items["metadata"] = nuspecReader;
return description;
}
return null;
}
// DNU REFACTORING TODO: temp hack to make generated lockfile work with runtime lockfile validation
private static string RuntimeStyleLibraryRangeToString(LibraryRange libraryRange)
{
var sb = new StringBuilder();
sb.Append(libraryRange.Name);
sb.Append(" ");
if (libraryRange.VersionRange == null)
{
return sb.ToString();
}
var minVersion = libraryRange.VersionRange.MinVersion;
var maxVersion = libraryRange.VersionRange.MaxVersion;
sb.Append(">= ");
if (libraryRange.VersionRange.IsFloating)
{
sb.Append(libraryRange.VersionRange.Float.ToString());
}
else
{
sb.Append(minVersion.ToString());
}
if (maxVersion != null)
{
sb.Append(libraryRange.VersionRange.IsMaxInclusive ? "<= " : "< ");
sb.Append(maxVersion.Version.ToString());
}
return sb.ToString();
}
public LibraryDescription GetDescription(LibraryRange libraryRange, NuGetFramework targetFramework)
{
if (!LibraryType.ReferenceAssembly.CanSatisfyConstraint(libraryRange.Target))
{
return null;
}
var name = libraryRange.Name;
var version = libraryRange.VersionRange?.MinVersion;
string path;
Version assemblyVersion;
if (!FrameworkResolver.TryGetAssembly(name, targetFramework, out path, out assemblyVersion))
{
return null;
}
return new LibraryDescription(
new LibraryIdentity(libraryRange.Name, new NuGetVersion(assemblyVersion), LibraryType.ReferenceAssembly),
string.Empty, // Framework assemblies don't have hashes
path,
Enumerable.Empty<LibraryRange>(),
targetFramework,
resolved: true,
compatible: true);
}
public async Task<WalkProviderMatch> FindLibrary(LibraryRange libraryRange, FrameworkName targetFramework)
{
var results = await _source.FindPackagesByIdAsync(libraryRange.Name);
PackageInfo bestResult = null;
foreach (var result in results)
{
if (VersionUtility.ShouldUseConsidering(
current: bestResult?.Version,
considering: result.Version,
ideal: libraryRange.VersionRange))
{
bestResult = result;
}
}
if (bestResult == null)
{
return null;
}
return new WalkProviderMatch
{
Library = new Library
{
Name = bestResult.Id,
Version = bestResult.Version
},
Path = bestResult.ContentUri,
Provider = this,
};
}
public static int RunPackageInstall(LibraryRange dependency, string projectPath, IEnumerable<string> args)
{
var result = RunDnx(new List<string> { "install", dependency.Name, dependency.VersionRange.OriginalString, projectPath }.Concat(args))
.ForwardStdErr()
.ForwardStdOut()
.Execute();
return result.ExitCode;
}
public Library GetLibrary(LibraryRange libraryRange, NuGetFramework targetFramework)
{
ExternalProjectReference externalProject;
if (!ExternalProjects.TryGetValue(libraryRange.Name, out externalProject))
{
// No project!
return null;
}
// Fill dependencies from external project references
var dependencies = externalProject.ExternalProjectReferences.Select(s => new LibraryDependency()
{
LibraryRange = new LibraryRange()
{
Name = s,
VersionRange = null,
TypeConstraint = LibraryTypes.ExternalProject
},
Type = LibraryDependencyType.Default
}).ToList();
// Add dependencies from the nuget.json file
if (!string.IsNullOrEmpty(externalProject.PackageSpecPath)
&& File.Exists(externalProject.PackageSpecPath))
{
PackageSpec packageSpec;
using (var stream = new FileStream(externalProject.PackageSpecPath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
packageSpec = JsonPackageSpecReader.GetPackageSpec(stream, externalProject.Name, externalProject.PackageSpecPath);
}
// Add framework-agnostic dependencies
dependencies.AddRange(packageSpec.Dependencies);
// Add framework-specific dependencies
var frameworkInfo = packageSpec.GetTargetFramework(targetFramework);
if (frameworkInfo != null)
{
dependencies.AddRange(frameworkInfo.Dependencies);
}
}
// Construct the library and return it
return new Library()
{
Identity = new LibraryIdentity()
{
Name = externalProject.Name,
Version = new NuGetVersion("1.0.0"),
Type = LibraryTypes.ExternalProject
},
LibraryRange = libraryRange,
Dependencies = dependencies,
Path = externalProject.PackageSpecPath,
Resolved = true
};
}
private static DependencyItem GetDependencyItem(LibraryRange dependency,
IDictionary<string, LibraryExport> exportsLookup)
{
return new DependencyItem
{
Name = dependency.Name,
Version = exportsLookup[dependency.Name].Library.Identity.Version?.ToNormalizedString()
};
}
public Task<LibraryIdentity> FindLibraryAsync(LibraryRange libraryRange, NuGetFramework targetFramework, CancellationToken cancellationToken)
{
var library = _dependencyProvider.GetLibrary(libraryRange, targetFramework);
if (library == null)
{
return Task.FromResult<LibraryIdentity>(null);
}
return Task.FromResult(library.Identity);
}
public static LibraryDescription GetDescription(LibraryRange libraryRange, NuGetFramework targetFramework)
{
return new LibraryDescription(
new LibraryIdentity(libraryRange.Name, libraryRange.VersionRange?.MinVersion, libraryRange.Target),
hash: null,
path: null,
dependencies: Enumerable.Empty<LibraryRange>(),
framework: targetFramework,
resolved: false,
compatible: true);
}
private string RenderDependency(LibraryRange arg)
{
var name = arg.Name;
if (arg.Target == LibraryType.ReferenceAssembly)
{
name = $"fx/{name}";
}
return $"{name} {VersionUtility.RenderVersion(arg.VersionRange)}";
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (libraryRange.IsGacOrFrameworkReference)
{
return null;
}
if (!DependencyTargets.SupportsProject(libraryRange.Target))
{
return null;
}
string name = libraryRange.Name;
Runtime.Project project;
// Can't find a project file with the name so bail
if (!_projectResolver.TryResolveProject(name, out project))
{
return null;
}
// This never returns null
var targetFrameworkInfo = project.GetCompatibleTargetFramework(targetFramework);
var dependencies = project.Dependencies.Concat(targetFrameworkInfo.Dependencies).ToList();
if (!dependencies.Any(d => d.Name.Equals(ImplicitPackagesWalkProvider.ImplicitRuntimePackageId)))
{
dependencies.Add(new LibraryDependency()
{
LibraryRange = new LibraryRange(ImplicitPackagesWalkProvider.ImplicitRuntimePackageId, frameworkReference: false)
{
VersionRange = new SemanticVersionRange()
{
MinVersion = ImplicitPackagesWalkProvider.ImplicitRuntimePackageVersion,
MaxVersion = ImplicitPackagesWalkProvider.ImplicitRuntimePackageVersion,
IsMaxInclusive = true,
VersionFloatBehavior = SemanticVersionFloatBehavior.None
}
}
});
}
return new ProjectDescription(
libraryRange,
project,
dependencies,
Enumerable.Empty<string>(),
targetFrameworkInfo,
resolved: true);
}
public static Task <GraphItem <RemoteResolveResult> > FindLibraryCachedAsync(
ConcurrentDictionary <LibraryRangeCacheKey, Task <GraphItem <RemoteResolveResult> > > cache,
LibraryRange libraryRange,
NuGetFramework framework,
string runtimeIdentifier,
GraphEdge <RemoteResolveResult> outerEdge,
RemoteWalkContext context,
CancellationToken cancellationToken)
{
var key = new LibraryRangeCacheKey(libraryRange, framework);
return(cache.GetOrAdd(key, (cacheKey) =>
FindLibraryEntryAsync(cacheKey.LibraryRange, framework, runtimeIdentifier, outerEdge, context, cancellationToken)));
}
public Task <GraphItem> FindLibraryCached(RestoreContext context, LibraryRange libraryRange)
{
lock (context.GraphItemCache)
{
Task <GraphItem> task;
if (!context.GraphItemCache.TryGetValue(libraryRange, out task))
{
task = FindLibraryEntry(context, libraryRange);
context.GraphItemCache[libraryRange] = task;
}
return(task);
}
}
private static RemoteMatch CreateUnresolvedMatch(LibraryRange libraryRange)
{
return(new RemoteMatch()
{
Library = new LibraryIdentity()
{
Name = libraryRange.Name,
Type = LibraryType.Unresolved,
Version = libraryRange.VersionRange?.MinVersion
},
Path = null,
Provider = null
});
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
return new LibraryDescription(
libraryRange,
new LibraryIdentity(libraryRange.Name, libraryRange.VersionRange?.MinVersion, libraryRange.IsGacOrFrameworkReference),
path: null,
type: LibraryTypes.Unresolved,
dependencies: Enumerable.Empty<LibraryDependency>(),
assemblies: Enumerable.Empty<string>(),
framework: null)
{
Resolved = false
};
}
private Task <RestoreTargetGraph> WalkDependenciesAsync(LibraryRange projectRange,
NuGetFramework framework,
RemoteDependencyWalker walker,
RemoteWalkContext context,
CancellationToken token)
{
return(WalkDependenciesAsync(projectRange,
framework,
runtimeIdentifier: null,
runtimeGraph: RuntimeGraph.Empty,
walker: walker,
context: context,
token: token));
}
private GraphItem <ResolveResult> Resolve(
Dictionary <LibraryRange, GraphItem <ResolveResult> > resolvedItems,
LibraryRange packageKey,
NuGetFramework framework)
{
GraphItem <ResolveResult> item;
if (resolvedItems.TryGetValue(packageKey, out item))
{
return(item);
}
ResolveResult hit = null;
foreach (var dependencyProvider in _dependencyProviders)
{
var match = dependencyProvider.GetDescription(packageKey, framework);
if (match != null)
{
hit = new ResolveResult
{
DependencyProvider = dependencyProvider,
LibraryDescription = match
};
break;
}
}
if (hit == null)
{
resolvedItems[packageKey] = null;
return(null);
}
if (resolvedItems.TryGetValue(hit.LibraryDescription.Identity, out item))
{
return(item);
}
item = new GraphItem <ResolveResult>(hit.LibraryDescription.Identity)
{
Data = hit
};
resolvedItems[packageKey] = item;
resolvedItems[hit.LibraryDescription.Identity] = item;
return(item);
}
private GraphItem <Library> Resolve(
Dictionary <LibraryRange, GraphItem <Library> > resolvedItems,
LibraryRange library,
NuGetFramework framework)
{
GraphItem <Library> item;
if (resolvedItems.TryGetValue(library, out item))
{
return(item);
}
Library hit = null;
foreach (var dependencyProvider in _dependencyProviders)
{
// Skip unsupported library type
if (!dependencyProvider.SupportsType(library.TypeConstraint))
{
continue;
}
hit = dependencyProvider.GetLibrary(library, framework);
if (hit != null)
{
break;
}
}
if (hit == null)
{
resolvedItems[library] = null;
return(null);
}
if (resolvedItems.TryGetValue(hit.Identity, out item))
{
return(item);
}
item = new GraphItem <Library>(hit.Identity)
{
Data = hit
};
resolvedItems[library] = item;
resolvedItems[hit.Identity] = item;
return(item);
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
return new LibraryDescription
{
LibraryRange = libraryRange,
Identity = new Library
{
Name = libraryRange.Name,
IsGacOrFrameworkReference = libraryRange.IsGacOrFrameworkReference,
Version = libraryRange.VersionRange?.MinVersion
},
Dependencies = Enumerable.Empty<LibraryDependency>(),
Resolved = false
};
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (!libraryRange.IsGacOrFrameworkReference)
{
return null;
}
if (PlatformHelper.IsMono)
{
return null;
}
if (!VersionUtility.IsDesktop(targetFramework))
{
return null;
}
var name = libraryRange.Name;
var version = libraryRange.VersionRange?.MinVersion;
string path;
if (!TryResolvePartialName(name, out path))
{
return null;
}
SemanticVersion assemblyVersion = VersionUtility.GetAssemblyVersion(path);
if (version == null || version == assemblyVersion)
{
_resolvedPaths[name] = path;
return new LibraryDescription
{
LibraryRange = libraryRange,
Identity = new Library
{
Name = name,
Version = assemblyVersion,
IsGacOrFrameworkReference = true
},
LoadableAssemblies = new[] { name },
Dependencies = Enumerable.Empty<LibraryDependency>()
};
}
return null;
}
private async Task <LibraryIdentity> FindLibraryCoreAsync(
LibraryRange libraryRange,
NuGetFramework targetFramework,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken cancellationToken)
{
try
{
await EnsureResource();
if (libraryRange.VersionRange?.MinVersion != null && libraryRange.VersionRange?.IsFloating != true)
{
// first check if the exact min version exist then simply return that
if (await _findPackagesByIdResource.DoesPackageExistAsync(
libraryRange.Name, libraryRange.VersionRange.MinVersion, cacheContext, logger, cancellationToken))
{
return(new LibraryIdentity
{
Name = libraryRange.Name,
Version = libraryRange.VersionRange.MinVersion,
Type = LibraryType.Package
});
}
}
// Discover all versions from the feed
var packageVersions = await GetAllVersionsAsync(libraryRange.Name, cacheContext, logger, cancellationToken);
// Select the best match
var packageVersion = packageVersions?.FindBestMatch(libraryRange.VersionRange, version => version);
if (packageVersion != null)
{
return(new LibraryIdentity
{
Name = libraryRange.Name,
Version = packageVersion,
Type = LibraryType.Package
});
}
}
catch (FatalProtocolException e) when(_ignoreFailedSources)
{
await LogWarningAsync(libraryRange.Name, e);
}
return(null);
}
public Task <WalkProviderMatch> FindLibrary(LibraryRange libraryRange, FrameworkName targetFramework, bool includeUnlisted)
{
var description = _dependencyProvider.GetDescription(libraryRange, targetFramework);
if (description == null)
{
return(Task.FromResult <WalkProviderMatch>(null));
}
return(Task.FromResult(new WalkProviderMatch
{
Library = description.Identity,
Path = description.Path,
Provider = this,
}));
}
public Task<WalkProviderMatch> FindLibrary(LibraryRange libraryRange, FrameworkName targetFramework)
{
var description = _dependencyProvider.GetDescription(libraryRange, targetFramework);
if (description == null)
{
return Task.FromResult<WalkProviderMatch>(null);
}
return Task.FromResult(new WalkProviderMatch
{
Library = description.Identity,
Path = description.Path,
Provider = this,
});
}
public Task <LibraryIdentity> FindLibraryAsync(
LibraryRange libraryRange,
NuGetFramework targetFramework,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken cancellationToken)
{
var library = _dependencyProvider.GetLibrary(libraryRange, targetFramework);
if (library == null)
{
return(Task.FromResult <LibraryIdentity>(null));
}
return(Task.FromResult(library.Identity));
}
public Task <RemoteMatch> FindLibrary(LibraryRange libraryRange, NuGetFramework targetFramework)
{
var description = _dependencyProvider.GetDescription(libraryRange, targetFramework);
if (description == null)
{
return(Task.FromResult <RemoteMatch>(null));
}
return(Task.FromResult(new RemoteMatch
{
Library = description.Identity,
Path = description.Path,
Provider = this,
}));
}
[InlineData(LibraryDependencyTarget.Package, LibraryDependencyTarget.Assembly, false)] // different
public void LibraryRange_Equals_TypeConstraint(
LibraryDependencyTarget typeConstraintA,
LibraryDependencyTarget typeConstraintB,
bool expected)
{
// Arrange
var version = VersionRange.Parse("1.0.0");
var rangeA = new LibraryRange("packageA", version, typeConstraintA);
var rangeB = new LibraryRange("packageA", version, typeConstraintB);
// Act
var actual = rangeA.Equals(rangeB);
// Assert
Assert.Equal(expected, actual);
}
private async Task <WalkProviderMatch> FindProjectMatch(RestoreContext context, string name)
{
var libraryRange = new LibraryRange(name, frameworkReference: false);
foreach (var provider in context.ProjectLibraryProviders)
{
var match = await provider.FindLibrary(libraryRange, context.FrameworkName, includeUnlisted : false);
if (match != null)
{
return(match);
}
}
return(null);
}
private static async Task <RestoreLogMessage> GetMessage(LibraryRange range, List <NuGetVersion> versions)
{
var token = CancellationToken.None;
var logger = new TestLogger();
var provider = GetProvider("http://nuget.org/a/", versions);
var cacheContext = new Mock <SourceCacheContext>();
var remoteLibraryProviders = new List <IRemoteDependencyProvider>()
{
provider.Object
};
var targetGraphName = "abc";
var message = await UnresolvedMessages.GetMessageAsync(targetGraphName, range, remoteLibraryProviders, false, remoteLibraryProviders, cacheContext.Object, logger, token);
return(message);
}
private static void PersistLockFile(LibraryRange tooldep, string tempPath, string projectPath)
{
var sourcePath = Path.Combine(tempPath, "project.lock.json");
var targetDir = Path.Combine(projectPath, "artifacts", "Tools", tooldep.Name);
var targetPath = Path.Combine(targetDir, "project.lock.json");
if (Directory.Exists(targetDir))
{
Directory.Delete(targetDir, true);
}
Directory.CreateDirectory(targetDir);
Console.WriteLine($"Writing '{sourcePath}' to '{targetPath}'");
File.Move(sourcePath, targetPath);
}
private async Task <RestoreTargetGraph> WalkDependencies(LibraryRange projectRange, NuGetFramework framework, string runtimeIdentifier, RuntimeGraph runtimeGraph, RemoteDependencyWalker walker, RemoteWalkContext context)
{
_log.LogInformation($"Restoring packages for {framework}");
var graph = await walker.Walk(
projectRange,
framework,
runtimeIdentifier,
runtimeGraph);
// Resolve conflicts
_log.LogVerbose($"Resolving Conflicts for {framework}");
bool inConflict = !graph.TryResolveConflicts();
// Flatten and create the RestoreTargetGraph to hold the packages
return(RestoreTargetGraph.Create(inConflict, framework, runtimeIdentifier, runtimeGraph, graph, context, _loggerFactory));
}
public async Task GivenAnUnresolvedReferenceVerifyMessage()
{
var range = new LibraryRange("x", VersionRange.All, LibraryDependencyTarget.Reference);
var versions = new List <NuGetVersion>()
{
NuGetVersion.Parse("1.0.0-beta"), NuGetVersion.Parse("4.4.0-beta.2+test")
};
var message = await GetMessage(range, versions);
message.Code.Should().Be(NuGetLogCode.NU1100);
message.LibraryId.Should().Be("x");
message.Message.Should().Contain("Unable to resolve 'reference/x ' for 'abc'");
message.TargetGraphs.Should().BeEquivalentTo(new[] { "abc" });
message.Level.Should().Be(LogLevel.Error);
}
public async Task <LibraryIdentity> FindLibraryAsync(LibraryRange libraryRange, NuGetFramework targetFramework, CancellationToken cancellationToken)
{
await EnsureResource();
IEnumerable <NuGetVersion> packageVersions = null;
try
{
if (_throttle != null)
{
await _throttle.WaitAsync();
}
packageVersions = await _findPackagesByIdResource.GetAllVersionsAsync(libraryRange.Name, cancellationToken);
}
catch (FatalProtocolException e) when(_ignoreFailedSources)
{
if (!_ignoreWarning)
{
_logger.LogWarning(e.Message);
}
return(null);
}
finally
{
_throttle?.Release();
}
var packageVersion = packageVersions?.FindBestMatch(libraryRange.VersionRange, version => version);
if (packageVersion != null)
{
// Use the original package identity for the library identity
var packageIdentity = await _findPackagesByIdResource.GetOriginalIdentityAsync(
libraryRange.Name,
packageVersion,
cancellationToken);
return(new LibraryIdentity
{
Name = packageIdentity.Id,
Version = packageIdentity.Version,
Type = LibraryType.Package
});
}
return(null);
}
public Library GetDescription(LibraryRange libraryRange, NuGetFramework targetFramework)
{
var library = FindCandidate(libraryRange);
if (library != null)
{
IEnumerable <LibraryDependency> dependencies;
bool resolved = true;
var frameworkGroup = library.FrameworkGroups.FirstOrDefault(g => g.TargetFramework.Equals(targetFramework));
if (frameworkGroup == null)
{
// Library does not exist for this target framework
dependencies = Enumerable.Empty <LibraryDependency>();
resolved = false;
}
else
{
dependencies = GetDependencies(frameworkGroup);
}
var description = new Library
{
LibraryRange = libraryRange,
Identity = new LibraryIdentity
{
Name = library.Name,
Version = library.Version,
Type = LibraryTypes.Package
},
Resolved = resolved,
Dependencies = dependencies,
[KnownLibraryProperties.LockFileLibrary] = library,
[KnownLibraryProperties.LockFileFrameworkGroup] = frameworkGroup
};
description.Items[KnownLibraryProperties.LockFileLibrary] = library;
if (frameworkGroup != null)
{
description.Items[KnownLibraryProperties.LockFileFrameworkGroup] = frameworkGroup;
}
return(description);
}
return(null);
}
private static async Task <WalkProviderMatch> FindLibrary(
LibraryRange libraryRange,
IEnumerable <IWalkProvider> providers,
Func <IWalkProvider, Task <WalkProviderMatch> > action)
{
var tasks = new List <Task <WalkProviderMatch> >();
foreach (var provider in providers)
{
tasks.Add(action(provider));
}
WalkProviderMatch bestMatch = null;
var matches = new List <WalkProviderMatch>();
// Short circuit if we find an exact match
while (tasks.Any())
{
var task = await Task.WhenAny(tasks);
tasks.Remove(task);
var match = await task;
// If we found an exact match then use it
if (libraryRange.VersionRange.VersionFloatBehavior == SemanticVersionFloatBehavior.None &&
match != null &&
match.Library.Version.Equals(libraryRange.VersionRange.MinVersion))
{
return(match);
}
matches.Add(match);
}
foreach (var match in matches)
{
if (VersionUtility.ShouldUseConsidering(
current: bestMatch?.Library?.Version,
considering: match?.Library?.Version,
ideal: libraryRange.VersionRange))
{
bestMatch = match;
}
}
return(bestMatch);
}
public async Task <GraphNode> CreateGraphNode(RestoreContext context, LibraryRange libraryRange, Func <string, bool> predicate)
{
var sw = new Stopwatch();
sw.Start();
var node = new GraphNode
{
LibraryRange = libraryRange,
Item = await FindLibraryCached(context, libraryRange),
};
if (node.Item != null)
{
if (node.LibraryRange.VersionRange != null &&
node.LibraryRange.VersionRange.VersionFloatBehavior != SemanticVersionFloatBehavior.None)
{
lock (context.FindLibraryCache)
{
if (!context.FindLibraryCache.ContainsKey(node.LibraryRange))
{
context.FindLibraryCache[node.LibraryRange] = Task.FromResult(node.Item);
}
}
}
var tasks = new List <Task <GraphNode> >();
var dependencies = node.Item.Dependencies ?? Enumerable.Empty <LibraryDependency>();
foreach (var dependency in dependencies)
{
if (predicate(dependency.Name))
{
tasks.Add(CreateGraphNode(context, dependency.LibraryRange, ChainPredicate(predicate, node.Item, dependency)));
}
}
while (tasks.Any())
{
var task = await Task.WhenAny(tasks);
tasks.Remove(task);
var dependency = await task;
node.Dependencies.Add(dependency);
}
}
return(node);
}
public Task <WalkProviderMatch> FindLibrary(LibraryRange libraryRange, FrameworkName targetFramework, bool includeUnlisted)
{
// If the package matches an embedded package, return it
if (libraryRange.Name.Equals(ImplicitRuntimePackageConstants.ImplicitRuntimePackageId))
{
return(Task.FromResult(new WalkProviderMatch()
{
Provider = this,
LibraryType = LibraryTypes.Implicit,
Library = new LibraryIdentity(
ImplicitRuntimePackageConstants.ImplicitRuntimePackageId,
ImplicitRuntimePackageConstants.ImplicitRuntimePackageVersion,
isGacOrFrameworkReference: false)
}));
}
return(Task.FromResult <WalkProviderMatch>(null));
}
public ProjectDescription(
LibraryRange libraryRange,
Project project,
IEnumerable<LibraryRange> dependencies,
TargetFrameworkInformation targetFrameworkInfo,
bool resolved)
: base(new LibraryIdentity(project.Name, project.Version, LibraryType.Project),
string.Empty, // Projects don't have hashes
project.ProjectFilePath,
dependencies,
targetFrameworkInfo.FrameworkName,
resolved,
compatible: true)
{
Project = project;
TargetFrameworkInfo = targetFrameworkInfo;
}
public async Task GivenAnUnresolvedPackageWithPreRelVersionsAndPreRelRangeVerifyMessage()
{
var range = new LibraryRange("x", VersionRange.Parse("[4.0.0-beta, 5.0.0]"), LibraryDependencyTarget.Package);
var versions = new List <NuGetVersion>()
{
NuGetVersion.Parse("1.0.0-beta"), NuGetVersion.Parse("4.4.0-beta.2+test")
};
var message = await GetMessage(range, versions);
message.Code.Should().Be(NuGetLogCode.NU1102);
message.LibraryId.Should().Be("x");
message.Message.Should().Contain("Unable to find package x with version (>= 4.0.0-beta && <= 5.0.0)");
message.Message.Should().Contain("Found 2 version(s) in http://nuget.org/a/ [ Nearest version: 4.4.0-beta.2 ]");
message.TargetGraphs.Should().BeEquivalentTo(new[] { "abc" });
message.Level.Should().Be(LogLevel.Error);
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (libraryRange.IsGacOrFrameworkReference)
{
return(null);
}
if (!DependencyTargets.SupportsProject(libraryRange.Target))
{
return(null);
}
string name = libraryRange.Name;
Runtime.Project project;
// Can't find a project file with the name so bail
if (!_projectResolver.TryResolveProject(name, out project))
{
return(null);
}
// This never returns null
var targetFrameworkInfo = project.GetCompatibleTargetFramework(targetFramework);
var dependencies = project.Dependencies.Concat(targetFrameworkInfo.Dependencies).ToList();
if (!dependencies.Any(d => d.Name.Equals(ImplicitRuntimePackageConstants.ImplicitRuntimePackageId)))
{
dependencies.Add(new LibraryDependency()
{
LibraryRange = new LibraryRange(ImplicitRuntimePackageConstants.ImplicitRuntimePackageId, frameworkReference: false)
{
VersionRange = new SemanticVersionRange(ImplicitRuntimePackageConstants.ImplicitRuntimePackageVersion)
}
});
}
return(new ProjectDescription(
libraryRange,
project,
dependencies,
Enumerable.Empty <string>(),
targetFrameworkInfo,
resolved: true));
}
public async Task GivenAnUnresolvedProjectWithNotFoundVerifyMessage()
{
var path = Path.Combine(Directory.GetCurrentDirectory(), "notfound.csproj");
var range = new LibraryRange(path, VersionRange.All, LibraryDependencyTarget.ExternalProject);
var versions = new List <NuGetVersion>()
{
NuGetVersion.Parse("1.0.0-beta"), NuGetVersion.Parse("4.4.0-beta.2+test")
};
var message = await GetMessage(range, versions);
message.Code.Should().Be(NuGetLogCode.NU1104);
message.LibraryId.Should().Be(path);
message.Message.Should().Contain($"Unable to find project '{path}'");
message.TargetGraphs.Should().BeEquivalentTo(new[] { "abc" });
message.Level.Should().Be(LogLevel.Error);
}
private static async Task <RestoreLogMessage> GetMessage(LibraryRange range, List <NuGetVersion> versions)
{
var token = CancellationToken.None;
var logger = new TestLogger();
var provider = GetProvider("http://nuget.org/a/", versions);
var cacheContext = new Mock <SourceCacheContext>();
var remoteWalkContext = new RemoteWalkContext(cacheContext.Object, NullLogger.Instance);
remoteWalkContext.RemoteLibraryProviders.Add(provider.Object);
var graph = new Mock <IRestoreTargetGraph>();
graph.SetupGet(e => e.TargetGraphName).Returns("abc");
var message = await UnresolvedMessages.GetMessageAsync(graph.Object, range, remoteWalkContext, logger, token);
return(message);
}
public LibraryDescription(
LibraryRange requestedRange,
LibraryIdentity identity,
string path,
string type,
IEnumerable<LibraryDependency> dependencies,
IEnumerable<string> assemblies,
FrameworkName framework)
{
Path = path;
RequestedRange = requestedRange;
Identity = identity;
Type = type;
Dependencies = dependencies ?? Enumerable.Empty<LibraryDependency>();
Assemblies = assemblies ?? Enumerable.Empty<string>();
Framework = framework;
}
public async Task<GraphNode> CreateGraphNode(RestoreContext context, LibraryRange libraryRange, Func<string, bool> predicate)
{
var sw = new Stopwatch();
sw.Start();
var node = new GraphNode
{
LibraryRange = libraryRange,
Item = await FindLibraryCached(context, libraryRange),
};
if (node.Item != null)
{
if (node.LibraryRange.VersionRange != null &&
node.LibraryRange.VersionRange.VersionFloatBehavior != SemanticVersionFloatBehavior.None)
{
lock (context.FindLibraryCache)
{
if (!context.FindLibraryCache.ContainsKey(node.LibraryRange))
{
context.FindLibraryCache[node.LibraryRange] = Task.FromResult(node.Item);
}
}
}
var tasks = new List<Task<GraphNode>>();
var dependencies = node.Item.Dependencies ?? Enumerable.Empty<LibraryDependency>();
foreach (var dependency in dependencies)
{
if (predicate(dependency.Name))
{
tasks.Add(CreateGraphNode(context, dependency.LibraryRange, ChainPredicate(predicate, node.Item, dependency)));
}
}
while (tasks.Any())
{
var task = await Task.WhenAny(tasks);
tasks.Remove(task);
var dependency = await task;
node.Dependencies.Add(dependency);
}
}
return node;
}
/// <summary>
/// Asynchronously discovers all versions of a package from a source and selects the best match.
/// </summary>
/// <remarks>This does not download the package.</remarks>
/// <param name="libraryRange">A library range.</param>
/// <param name="targetFramework">A target framework.</param>
/// <param name="cacheContext">A source cache context.</param>
/// <param name="logger">A logger.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <returns>A task that represents the asynchronous operation.
/// The task result (<see cref="Task{TResult}.Result" />) returns a <see cref="LibraryIdentity" />
/// instance.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="libraryRange" />
/// is either <c>null</c> or empty.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="targetFramework" />
/// is either <c>null</c> or empty.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="cacheContext" />
/// is either <c>null</c> or empty.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" />
/// is either <c>null</c> or empty.</exception>
/// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" />
/// is cancelled.</exception>
public async Task <LibraryIdentity> FindLibraryAsync(
LibraryRange libraryRange,
NuGetFramework targetFramework,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken cancellationToken)
{
if (libraryRange == null)
{
throw new ArgumentNullException(nameof(libraryRange));
}
if (targetFramework == null)
{
throw new ArgumentNullException(nameof(targetFramework));
}
if (cacheContext == null)
{
throw new ArgumentNullException(nameof(cacheContext));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
cancellationToken.ThrowIfCancellationRequested();
AsyncLazy <LibraryIdentity> result = null;
var action = new AsyncLazy <LibraryIdentity>(async() =>
await FindLibraryCoreAsync(libraryRange, cacheContext, logger, cancellationToken));
if (cacheContext.RefreshMemoryCache)
{
result = _libraryMatchCache.AddOrUpdate(libraryRange, action, (k, v) => action);
}
else
{
result = _libraryMatchCache.GetOrAdd(libraryRange, action);
}
return(await result);
}
public Task <GraphItem <RemoteResolveResult> > FindLibraryCached(
Dictionary <LibraryRange, Task <GraphItem <RemoteResolveResult> > > cache,
LibraryRange libraryRange,
NuGetFramework framework,
CancellationToken cancellationToken = default(CancellationToken))
{
lock (cache)
{
Task <GraphItem <RemoteResolveResult> > task;
if (!cache.TryGetValue(libraryRange, out task))
{
task = FindLibraryEntry(libraryRange, framework, cancellationToken);
cache[libraryRange] = task;
}
return(task);
}
}
/// <summary>
/// Gets the best matching PackageIdentity for the specified LibraryRange.
/// </summary>
/// <param name="identity">The library range to find the best patch for.</param>
/// <param name="findPackageResource">The source repository where to match.</param>
/// <param name="token">A optional cancellation token.</param>
/// <returns>The best matching PackageIdentity to the specified version range.</returns>
public static async Task <PackageIdentity> GetBestMatch(LibraryRange identity, FindPackageByIdResource findPackageResource, CancellationToken token)
{
if (identity == null)
{
throw new ArgumentNullException(nameof(identity));
}
if (findPackageResource == null)
{
throw new ArgumentNullException(nameof(findPackageResource));
}
var versions = await findPackageResource.GetAllVersionsAsync(identity.Name, _sourceCacheContext, _logger, token).ConfigureAwait(false);
var bestPackageVersion = versions?.FindBestMatch(identity.VersionRange, version => version);
return(new PackageIdentity(identity.Name, bestPackageVersion));
}
public ProjectDescription(
LibraryRange libraryRange,
Project project,
IEnumerable <LibraryRange> dependencies,
TargetFrameworkInformation targetFrameworkInfo,
bool resolved) :
base(
new LibraryIdentity(project.Name, project.Version, LibraryType.Project),
string.Empty, // Projects don't have hashes
project.ProjectFilePath,
dependencies,
targetFrameworkInfo.FrameworkName,
resolved,
compatible: true)
{
Project = project;
TargetFrameworkInfo = targetFrameworkInfo;
}
public ProjectDescription(
LibraryRange libraryRange,
Project project,
IEnumerable<LibraryDependency> dependencies,
IEnumerable<string> assemblies,
FrameworkName framework,
bool resolved)
: base(libraryRange,
new LibraryIdentity(project.Name, project.Version, isGacOrFrameworkReference: false),
project.ProjectFilePath,
LibraryTypes.Project,
dependencies,
assemblies,
framework)
{
Project = project;
Resolved = resolved;
Compatible = resolved;
}
public static Task <GraphItem <RemoteResolveResult> > FindLibraryCachedAsync(
ConcurrentDictionary <LibraryRangeCacheKey, Task <GraphItem <RemoteResolveResult> > > cache,
LibraryRange libraryRange,
NuGetFramework framework,
string runtimeIdentifier,
RemoteWalkContext context,
CancellationToken cancellationToken)
{
var key = new LibraryRangeCacheKey(libraryRange, framework);
if (cache.TryGetValue(key, out var graphItem))
{
return(graphItem);
}
graphItem = cache.GetOrAdd(key, FindLibraryEntryAsync(key.LibraryRange, framework, runtimeIdentifier, context, cancellationToken));
return(graphItem);
}
public PackageDescription(
LibraryRange requestedRange,
PackageInfo package,
LockFileTargetLibrary lockFileLibrary,
IEnumerable<LibraryDependency> dependencies,
bool resolved,
bool compatible)
: base(requestedRange,
new LibraryIdentity(package.Id, package.Version, isGacOrFrameworkReference: false),
path: null,
type: LibraryTypes.Package,
dependencies: dependencies,
assemblies: Enumerable.Empty<string>(),
framework: null)
{
Package = package;
LockFileLibrary = lockFileLibrary;
Resolved = resolved;
Compatible = compatible;
}
public async Task<LibraryIdentity> FindLibraryAsync(LibraryRange libraryRange, NuGetFramework targetFramework, CancellationToken cancellationToken)
{
await EnsureResource();
var packageVersions = await _findPackagesByIdResource.GetAllVersionsAsync(libraryRange.Name, cancellationToken);
var packageVersion = packageVersions.FindBestMatch(libraryRange.VersionRange, version => version);
if (packageVersion != null)
{
return new LibraryIdentity
{
Name = libraryRange.Name,
Version = packageVersion,
Type = LibraryTypes.Package
};
}
return null;
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (!libraryRange.IsGacOrFrameworkReference)
{
return null;
}
if (!RuntimeEnvironmentHelper.IsWindows)
{
return null;
}
if (!VersionUtility.IsDesktop(targetFramework))
{
return null;
}
var name = libraryRange.Name;
var version = libraryRange.VersionRange?.MinVersion;
string path;
if (!TryResolvePartialName(libraryRange.GetReferenceAssemblyName(), version, out path))
{
return null;
}
_resolvedPaths[name] = path;
return new LibraryDescription
{
LibraryRange = libraryRange,
Identity = new Library
{
Name = name,
Version = version,
IsGacOrFrameworkReference = true
},
LoadableAssemblies = new[] { libraryRange.GetReferenceAssemblyName() },
Dependencies = Enumerable.Empty<LibraryDependency>()
};
}
private static void CreateDepsInPackageCache(LibraryRange toolLibrary, string projectPath)
{
var context = ProjectContext.Create(projectPath,
FrameworkConstants.CommonFrameworks.DnxCore50, new[] { DefaultRid });
var toolDescription = context.LibraryManager.GetLibraries()
.Select(l => l as PackageDescription)
.Where(l => l != null)
.FirstOrDefault(l => l.Identity.Name == toolLibrary.Name);
var depsPath = Path.Combine(
toolDescription.Path,
Path.GetDirectoryName(toolDescription.Target.RuntimeAssemblies.First().Path),
toolDescription.Identity.Name + FileNameSuffixes.Deps);
context.MakeCompilationOutputRunnable(context.ProjectDirectory, Constants.DefaultConfiguration);
if (File.Exists(depsPath)) File.Delete(depsPath);
File.Move(Path.Combine(context.ProjectDirectory, "bin" + FileNameSuffixes.Deps), depsPath);
}
