public Project(Runtime.Project runtimeProject)
{
ProjectFile = runtimeProject.ProjectFilePath;
ProjectDirectory = runtimeProject.ProjectDirectory;
Files = runtimeProject.Files.SourceFiles.Concat(
runtimeProject.Files.ResourceFiles.Values.Concat(
runtimeProject.Files.PreprocessSourceFiles.Concat(
runtimeProject.Files.SharedFiles))).Concat(
new string[] { runtimeProject.ProjectFilePath })
.ToList();
var projectLockJsonPath = Path.Combine(runtimeProject.ProjectDirectory, LockFileReader.LockFileName);
var lockFileReader = new LockFileReader();
if (File.Exists(projectLockJsonPath))
{
var lockFile = lockFileReader.Read(projectLockJsonPath);
ProjectDependencies = lockFile.ProjectLibraries.Select(dep => GetProjectRelativeFullPath(dep.Path)).ToList();
}
else
{
ProjectDependencies = new string[0];
}
}
public void TestExportFileIsParsed()
{
var lockFilePath = GetLockFilePath("valid");
var lockFile = LockFileReader.Read(lockFilePath, designTime: false);
var exportFile = lockFile.ExportFile;
exportFile.Should().NotBeNull();
exportFile.Exports.Count.Should().Be(3);
exportFile.Exports.Should().OnlyHaveUniqueItems();
// check export structure
foreach (var export in exportFile.Exports)
{
export.TargetFramework.Should().NotBeNull();
AssertTargetLibrary(export);
}
}
private FileModelEntry <LockFile> AddLockFileEntry(string projectDirectory, FileModelEntry <LockFile> currentEntry)
{
if (currentEntry == null)
{
currentEntry = new FileModelEntry <LockFile>();
}
else if (!File.Exists(Path.Combine(projectDirectory, LockFile.FileName)))
{
currentEntry.Reset();
return(currentEntry);
}
if (currentEntry.IsInvalid)
{
currentEntry.FilePath = Path.Combine(projectDirectory, LockFile.FileName);
currentEntry.Model = LockFileReader.Read(currentEntry.FilePath);
currentEntry.UpdateLastWriteTime();
}
return(currentEntry);
}
private FileModelEntry <LockFile> AddLockFileEntry(string projectDirectory, FileModelEntry <LockFile> currentEntry)
{
if (currentEntry == null)
{
currentEntry = new FileModelEntry <LockFile>();
}
if (currentEntry.IsInvalid)
{
currentEntry.Reset();
if (!File.Exists(Path.Combine(projectDirectory, LockFile.FileName)))
{
return(currentEntry);
}
else
{
currentEntry.FilePath = Path.Combine(projectDirectory, LockFile.FileName);
using (var fs = ResilientFileStreamOpener.OpenFile(currentEntry.FilePath, retry: 2))
{
try
{
currentEntry.Model = LockFileReader.Read(currentEntry.FilePath, fs);
currentEntry.UpdateLastWriteTimeUtc();
}
catch (FileFormatException ex)
{
throw ex.WithFilePath(currentEntry.FilePath);
}
catch (Exception ex)
{
throw FileFormatException.Create(ex, currentEntry.FilePath);
}
}
}
}
return(currentEntry);
}
private LockFile GetToolLockFile(
LibraryRange toolLibrary,
string nugetPackagesRoot)
{
var lockFilePath = GetToolLockFilePath(toolLibrary, nugetPackagesRoot);
if (!File.Exists(lockFilePath))
{
return(null);
}
LockFile lockFile = null;
try
{
lockFile = LockFileReader.Read(lockFilePath);
}
catch (FileFormatException ex)
{
throw ex;
}
return(lockFile);
}
public Project(ProjectModel.Project runtimeProject)
{
ProjectFile = runtimeProject.ProjectFilePath;
ProjectDirectory = runtimeProject.ProjectDirectory;
Files = runtimeProject.Files.SourceFiles.Concat(
runtimeProject.Files.ResourceFiles.Values.Concat(
runtimeProject.Files.PreprocessSourceFiles.Concat(
runtimeProject.Files.SharedFiles))).Concat(
new string[] { runtimeProject.ProjectFilePath })
.ToList();
var projectLockJsonPath = Path.Combine(runtimeProject.ProjectDirectory, "project.lock.json");
if (File.Exists(projectLockJsonPath))
{
var lockFile = LockFileReader.Read(projectLockJsonPath, designTime: false);
ProjectDependencies = lockFile.ProjectLibraries.Select(dep => GetProjectRelativeFullPath(dep.Path)).ToList();
}
else
{
ProjectDependencies = new string[0];
}
}
public void TestMissmatchingFileVersionsThrows()
{
var lockFilePath = GetLockFilePath("invalid_missmatching-versions");
Assert.Throws <FileFormatException>(() => LockFileReader.Read(lockFilePath));
}
public void TestMissingExportsThrow()
{
var lockFilePath = GetLockFilePath("invalid_missing-exports");
Assert.Throws <FileFormatException>(() => LockFileReader.Read(lockFilePath));
}
public void TestMissingExportFileThrows()
{
var lockFilePath = GetLockFilePath("invalid_nofragment");
Assert.Throws <FileFormatException>(() => LockFileReader.Read(lockFilePath));
}
public void TestMissmatchingFileVersionsUnderDesignTime()
{
var lockFilePath = GetLockFilePath("invalid_missmatching-versions");
Assert.NotNull(LockFileReader.Read(lockFilePath, designTime: true));
}
public void NullDependencyVersionsAreParsed()
{
var lockFileData = @"{
""locked"": false,
""version"": -9996,
""targets"": {
"".NETFramework,Version=v4.5"": {
""WindowsAzure.ServiceBus/2.6.7"": {
""dependencies"": {
""Microsoft.WindowsAzure.ConfigurationManager"": null
},
""frameworkAssemblies"": [
""System.ServiceModel"",
""System.Xml"",
""System.Runtime.Serialization""
],
""compile"": {
""lib/net40-full/Microsoft.ServiceBus.dll"": {}
},
""runtime"": {
""lib/net40-full/Microsoft.ServiceBus.dll"": {}
}
}
}
},
""libraries"": {
""WindowsAzure.ServiceBus/2.6.7"": {
""sha512"": ""AhQ4nya0Pu0tGev/Geqt5+yBTI+ov66ginMHCm+HqmXezTIOSfBu7HOI5RuvmiQqM99AeTuASD6gMz+zWueHNQ=="",
""files"": [
""WindowsAzure.ServiceBus.2.6.7.nupkg"",
""WindowsAzure.ServiceBus.2.6.7.nupkg.sha512"",
""WindowsAzure.ServiceBus.nuspec"",
""content/app.config.install.xdt"",
""content/web.config.install.xdt"",
""lib/net40-full/Microsoft.ServiceBus.dll"",
""lib/net40-full/Microsoft.ServiceBus.xml""
]
}
},
""projectFileDependencyGroups"": {
"""": [
""WindowsAzure.ServiceBus >= 2.6.7""
],
"".NETFramework,Version=v4.5"": []
}
}";
var reader = new LockFileReader();
var stream = new MemoryStream(Encoding.UTF8.GetBytes(lockFileData));
var lockFile = reader.Read(stream);
Assert.False(lockFile.Islocked);
Assert.Equal(1, lockFile.Targets.Count);
var library = lockFile.Targets[0].Libraries[0];
Assert.Equal("WindowsAzure.ServiceBus", library.Name);
Assert.Equal(SemanticVersion.Parse("2.6.7"), library.Version);
Assert.Equal(1, library.Dependencies.Count);
var dependency = library.Dependencies[0];
Assert.Equal(dependency.Id, "Microsoft.WindowsAzure.ConfigurationManager");
Assert.Null(dependency.VersionSpec);
}
public ApplicationHostContext(IServiceProvider serviceProvider,
string projectDirectory,
string packagesDirectory,
string configuration,
FrameworkName targetFramework,
ICache cache,
ICacheContextAccessor cacheContextAccessor,
INamedCacheDependencyProvider namedCacheDependencyProvider,
IAssemblyLoadContextFactory loadContextFactory = null,
bool skipLockFileValidation = false)
{
ProjectDirectory = projectDirectory;
Configuration = configuration;
RootDirectory = Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory);
FrameworkReferenceResolver = new FrameworkReferenceResolver();
_serviceProvider = new ServiceProvider(serviceProvider);
PackagesDirectory = packagesDirectory ?? NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(FrameworkReferenceResolver);
NuGetDependencyProvider = new NuGetDependencyResolver(new PackageRepository(PackagesDirectory));
var gacDependencyResolver = new GacDependencyResolver();
ProjectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
var projectName = PathUtility.GetDirectoryName(ProjectDirectory);
Project project;
if (ProjectResolver.TryResolveProject(projectName, out project))
{
Project = project;
}
else
{
throw new InvalidOperationException(
string.Format("Unable to resolve project '{0}' from {1}", projectName, ProjectDirectory));
}
var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFileReader.LockFileName);
var lockFileExists = File.Exists(projectLockJsonPath);
var validLockFile = false;
if (lockFileExists)
{
var lockFileReader = new LockFileReader();
var lockFile = lockFileReader.Read(projectLockJsonPath);
validLockFile = lockFile.IsValidForProject(Project);
if (validLockFile || skipLockFileValidation)
{
NuGetDependencyProvider.ApplyLockFile(lockFile);
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
ProjectDepencyProvider,
NuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
}
}
if ((!validLockFile && !skipLockFileValidation) || !lockFileExists)
{
// We don't add NuGetDependencyProvider to DependencyWalker
// It will leave all NuGet packages unresolved and give error message asking users to run "dnu restore"
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
ProjectDepencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
}
LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
new ProjectLibraryExportProvider(ProjectResolver, ServiceProvider),
referenceAssemblyDependencyResolver,
gacDependencyResolver,
NuGetDependencyProvider
});
LibraryManager = new LibraryManager(targetFramework, configuration, DependencyWalker,
LibraryExportProvider, cache);
AssemblyLoadContextFactory = loadContextFactory ?? new RuntimeLoadContextFactory(ServiceProvider);
namedCacheDependencyProvider = namedCacheDependencyProvider ?? NamedCacheDependencyProvider.Empty;
// Default services
_serviceProvider.Add(typeof(IApplicationEnvironment), new ApplicationEnvironment(Project, targetFramework, configuration));
_serviceProvider.Add(typeof(ILibraryManager), LibraryManager);
_serviceProvider.TryAdd(typeof(IFileWatcher), NoopWatcher.Instance);
// Not exposed to the application layer
_serviceProvider.Add(typeof(ILibraryExportProvider), LibraryExportProvider, includeInManifest: false);
_serviceProvider.Add(typeof(IProjectResolver), ProjectResolver, includeInManifest: false);
_serviceProvider.Add(typeof(NuGetDependencyResolver), NuGetDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(ProjectReferenceDependencyProvider), ProjectDepencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(ICache), cache, includeInManifest: false);
_serviceProvider.Add(typeof(ICacheContextAccessor), cacheContextAccessor, includeInManifest: false);
_serviceProvider.Add(typeof(INamedCacheDependencyProvider), namedCacheDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(IAssemblyLoadContextFactory), AssemblyLoadContextFactory, includeInManifest: false);
var compilerOptionsProvider = new CompilerOptionsProvider(ProjectResolver);
_serviceProvider.Add(typeof(ICompilerOptionsProvider), compilerOptionsProvider);
}
public ProjectContext Build()
{
ProjectDirectory = Project?.ProjectDirectory ?? ProjectDirectory;
if (GlobalSettings == null)
{
RootDirectory = ProjectRootResolver.ResolveRootDirectory(ProjectDirectory);
GlobalSettings globalSettings;
if (GlobalSettings.TryGetGlobalSettings(RootDirectory, out globalSettings))
{
GlobalSettings = globalSettings;
}
}
RootDirectory = GlobalSettings?.DirectoryPath ?? RootDirectory;
PackagesDirectory = PackagesDirectory ?? PackageDependencyProvider.ResolvePackagesPath(RootDirectory, GlobalSettings);
ReferenceAssembliesPath = ReferenceAssembliesPath ?? GetDefaultReferenceAssembliesPath();
LockFileLookup lockFileLookup = null;
EnsureProjectLoaded();
var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFile.FileName);
if (LockFile == null && File.Exists(projectLockJsonPath))
{
LockFile = LockFileReader.Read(projectLockJsonPath);
}
var validLockFile = true;
string lockFileValidationMessage = null;
if (LockFile != null)
{
validLockFile = LockFile.IsValidForProject(Project, out lockFileValidationMessage);
lockFileLookup = new LockFileLookup(LockFile);
}
var libraries = new Dictionary <LibraryKey, LibraryDescription>();
var projectResolver = new ProjectDependencyProvider();
var mainProject = projectResolver.GetDescription(TargetFramework, Project);
// Add the main project
libraries.Add(new LibraryKey(mainProject.Identity.Name), mainProject);
LockFileTarget target = null;
if (lockFileLookup != null)
{
target = SelectTarget(LockFile);
if (target != null)
{
var packageResolver = new PackageDependencyProvider(PackagesDirectory);
ScanLibraries(target, lockFileLookup, libraries, packageResolver, projectResolver);
}
}
var frameworkReferenceResolver = new FrameworkReferenceResolver(ReferenceAssembliesPath);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(frameworkReferenceResolver);
bool requiresFrameworkAssemblies;
// Resolve the dependencies
ResolveDependencies(libraries, referenceAssemblyDependencyResolver, out requiresFrameworkAssemblies);
var diagnostics = new List <DiagnosticMessage>();
// REVIEW: Should this be in NuGet (possibly stored in the lock file?)
if (LockFile == null)
{
diagnostics.Add(new DiagnosticMessage(
ErrorCodes.NU1009,
$"The expected lock file doesn't exist. Please run \"dotnet restore\" to generate a new lock file.",
Path.Combine(Project.ProjectDirectory, LockFile.FileName),
DiagnosticMessageSeverity.Error));
}
if (!validLockFile)
{
diagnostics.Add(new DiagnosticMessage(
ErrorCodes.NU1006,
$"{lockFileValidationMessage}. Please run \"dotnet restore\" to generate a new lock file.",
Path.Combine(Project.ProjectDirectory, LockFile.FileName),
DiagnosticMessageSeverity.Warning));
}
if (requiresFrameworkAssemblies)
{
var frameworkInfo = Project.GetTargetFramework(TargetFramework);
if (string.IsNullOrEmpty(ReferenceAssembliesPath))
{
// If there was an attempt to use reference assemblies but they were not installed
// report an error
diagnostics.Add(new DiagnosticMessage(
ErrorCodes.DOTNET1012,
$"The reference assemblies directory was not specified. You can set the location using the DOTNET_REFERENCE_ASSEMBLIES_PATH environment variable.",
filePath: Project.ProjectFilePath,
severity: DiagnosticMessageSeverity.Error,
startLine: frameworkInfo.Line,
startColumn: frameworkInfo.Column
));
}
else if (!frameworkReferenceResolver.IsInstalled(TargetFramework))
{
// If there was an attempt to use reference assemblies but they were not installed
// report an error
diagnostics.Add(new DiagnosticMessage(
ErrorCodes.DOTNET1011,
$"Framework not installed: {TargetFramework.DotNetFrameworkName} in {ReferenceAssembliesPath}",
filePath: Project.ProjectFilePath,
severity: DiagnosticMessageSeverity.Error,
startLine: frameworkInfo.Line,
startColumn: frameworkInfo.Column
));
}
}
// Create a library manager
var libraryManager = new LibraryManager(libraries.Values.ToList(), diagnostics, Project.ProjectFilePath);
return(new ProjectContext(
GlobalSettings,
mainProject,
TargetFramework,
target?.RuntimeIdentifier,
PackagesDirectory,
libraryManager));
}
public void NullDependencyVersionsAreParsed()
{
var lockFileData = @"{
""locked"": false,
""version"": 1,
""targets"": {
"".NETFramework,Version=v4.5"": {
""WindowsAzure.ServiceBus/2.6.7"": {
""dependencies"": {
""Microsoft.WindowsAzure.ConfigurationManager"": null
},
""frameworkAssemblies"": [
""System.ServiceModel"",
""System.Xml"",
""System.Runtime.Serialization""
],
""compile"": {
""lib/net40-full/Microsoft.ServiceBus.dll"": {}
},
""runtime"": {
""lib/net40-full/Microsoft.ServiceBus.dll"": {}
}
}
}
},
""libraries"": {
""WindowsAzure.ServiceBus/2.6.7"": {
""sha512"": ""AhQ4nya0Pu0tGev/Geqt5+yBTI+ov66ginMHCm+HqmXezTIOSfBu7HOI5RuvmiQqM99AeTuASD6gMz+zWueHNQ=="",
""files"": [
""WindowsAzure.ServiceBus.2.6.7.nupkg"",
""WindowsAzure.ServiceBus.2.6.7.nupkg.sha512"",
""WindowsAzure.ServiceBus.nuspec"",
""content/app.config.install.xdt"",
""content/web.config.install.xdt"",
""lib/net40-full/Microsoft.ServiceBus.dll"",
""lib/net40-full/Microsoft.ServiceBus.xml""
]
}
},
""projectFileDependencyGroups"": {
"""": [
""WindowsAzure.ServiceBus >= 2.6.7""
],
"".NETFramework,Version=v4.5"": []
}
}";
var reader = new LockFileReader();
var stream = new MemoryStream(Encoding.UTF8.GetBytes(lockFileData));
var lockFile = reader.Read(stream);
Assert.False(lockFile.Islocked);
Assert.Equal(1, lockFile.Targets.Count);
var library = lockFile.Targets[0].Libraries[0];
Assert.Equal("WindowsAzure.ServiceBus", library.Name);
Assert.Equal(SemanticVersion.Parse("2.6.7"), library.Version);
Assert.Equal(1, library.Dependencies.Count);
var dependency = library.Dependencies[0];
Assert.Equal(dependency.Id, "Microsoft.WindowsAzure.ConfigurationManager");
Assert.Null(dependency.VersionSpec);
}
public static void Initialize(ApplicationHostContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
context.ProjectDirectory = context.Project?.ProjectDirectory ?? context.ProjectDirectory;
context.RootDirectory = context.RootDirectory ?? ProjectResolver.ResolveRootDirectory(context.ProjectDirectory);
var projectResolver = new ProjectResolver(context.ProjectDirectory, context.RootDirectory);
var frameworkReferenceResolver = context.FrameworkResolver ?? new FrameworkReferenceResolver();
context.PackagesDirectory = context.PackagesDirectory ?? PackageDependencyProvider.ResolveRepositoryPath(context.RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(frameworkReferenceResolver);
var gacDependencyResolver = new GacDependencyResolver();
var projectDependencyProvider = new ProjectReferenceDependencyProvider(projectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
IList<IDependencyProvider> dependencyProviders = null;
LockFileLookup lockFileLookup = null;
if (context.Project == null)
{
Project project;
if (Project.TryGetProject(context.ProjectDirectory, out project))
{
context.Project = project;
}
else
{
throw new InvalidOperationException($"Unable to resolve project from {context.ProjectDirectory}");
}
}
var projectLockJsonPath = Path.Combine(context.ProjectDirectory, LockFileReader.LockFileName);
var lockFileExists = File.Exists(projectLockJsonPath);
var validLockFile = false;
var skipLockFileValidation = context.SkipLockfileValidation;
string lockFileValidationMessage = null;
if (lockFileExists)
{
var lockFileReader = new LockFileReader();
var lockFile = lockFileReader.Read(projectLockJsonPath);
validLockFile = lockFile.IsValidForProject(context.Project, out lockFileValidationMessage);
// When the only invalid part of a lock file is version number,
// we shouldn't skip lock file validation because we want to leave all dependencies unresolved, so that
// VS can be aware of this version mismatch error and automatically do restore
skipLockFileValidation = context.SkipLockfileValidation && (lockFile.Version == Constants.LockFileVersion);
if (validLockFile || skipLockFileValidation)
{
lockFileLookup = new LockFileLookup(lockFile);
var packageDependencyProvider = new PackageDependencyProvider(context.PackagesDirectory, lockFileLookup);
dependencyProviders = new IDependencyProvider[] {
projectDependencyProvider,
packageDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
};
}
}
if ((!validLockFile && !skipLockFileValidation) || !lockFileExists)
{
// We don't add the PackageDependencyProvider to DependencyWalker
// It will leave all NuGet packages unresolved and give error message asking users to run "dnu restore"
dependencyProviders = new IDependencyProvider[] {
projectDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
};
}
var libraries = DependencyWalker.Walk(dependencyProviders, context.Project.Name, context.Project.Version, context.TargetFramework);
context.LibraryManager = new LibraryManager(context.Project.ProjectFilePath, context.TargetFramework, libraries);
if (!validLockFile)
{
context.LibraryManager.AddGlobalDiagnostics(new DiagnosticMessage(
$"{lockFileValidationMessage}. Please run \"dnu restore\" to generate a new lock file.",
Path.Combine(context.Project.ProjectDirectory, LockFileReader.LockFileName),
DiagnosticMessageSeverity.Error));
}
if (!lockFileExists)
{
context.LibraryManager.AddGlobalDiagnostics(new DiagnosticMessage(
$"The expected lock file doesn't exist. Please run \"dnu restore\" to generate a new lock file.",
Path.Combine(context.Project.ProjectDirectory, LockFileReader.LockFileName),
DiagnosticMessageSeverity.Error));
}
// Clear all the temporary memory aggressively here if we don't care about reuse
// e.g. runtime scenarios
lockFileLookup?.Clear();
projectResolver.Clear();
}
private static Result InitializeCore(ApplicationHostContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
context.ProjectDirectory = context.Project?.ProjectDirectory ?? context.ProjectDirectory;
context.RootDirectory = context.RootDirectory ?? ProjectRootResolver.ResolveRootDirectory(context.ProjectDirectory);
context.PackagesDirectory = context.PackagesDirectory ?? PackageDependencyProvider.ResolveRepositoryPath(context.RootDirectory);
LockFileLookup lockFileLookup = null;
if (context.Project == null)
{
Project project;
if (Project.TryGetProject(context.ProjectDirectory, out project))
{
context.Project = project;
}
else
{
throw new InvalidOperationException($"Unable to resolve project from {context.ProjectDirectory}");
}
}
var projectLockJsonPath = Path.Combine(context.ProjectDirectory, LockFileReader.LockFileName);
if (context.LockFile == null && File.Exists(projectLockJsonPath))
{
var lockFileReader = new LockFileReader();
context.LockFile = lockFileReader.Read(projectLockJsonPath);
}
var validLockFile = true;
string lockFileValidationMessage = null;
if (context.LockFile != null)
{
validLockFile = (context.LockFile.Version == Constants.LockFileVersion) && context.LockFile.IsValidForProject(context.Project, out lockFileValidationMessage);
lockFileLookup = new LockFileLookup(context.LockFile);
}
var libraries = new List<LibraryDescription>();
var packageResolver = new PackageDependencyProvider(context.PackagesDirectory);
var projectResolver = new ProjectDependencyProvider();
context.MainProject = projectResolver.GetDescription(context.TargetFramework, context.Project);
// Add the main project
libraries.Add(context.MainProject);
if (lockFileLookup != null)
{
var target = SelectTarget(context, context.LockFile);
if (target != null)
{
if (Logger.IsEnabled && string.IsNullOrEmpty(target.RuntimeIdentifier))
{
// REVIEW(anurse): Is there ever a reason we want to use the RID-less target now?
Logger.TraceWarning($"[{nameof(ApplicationHostContext)}] Lock File Target is Runtime-agnostic! This is generally not good.");
}
Logger.TraceInformation($"[{nameof(ApplicationHostContext)}] Using Lock File Target: {target.TargetFramework}/{target.RuntimeIdentifier}");
foreach (var library in target.Libraries)
{
if (string.Equals(library.Type, "project"))
{
var projectLibrary = lockFileLookup.GetProject(library.Name);
var path = Path.GetFullPath(Path.Combine(context.ProjectDirectory, projectLibrary.Path));
var projectDescription = projectResolver.GetDescription(library.Name, path, library);
libraries.Add(projectDescription);
}
else
{
var packageEntry = lockFileLookup.GetPackage(library.Name, library.Version);
var packageDescription = packageResolver.GetDescription(packageEntry, library);
libraries.Add(packageDescription);
}
}
}
}
lockFileLookup?.Clear();
var lockFilePresent = context.LockFile != null;
context.LockFile = null; // LockFile is no longer needed
return new Result(libraries, lockFilePresent, validLockFile, lockFileValidationMessage);
}
