private static FscCommandSpec ResolveFsc(List <string> fscArgs, string temp) { var nugetPackagesRoot = PackageDependencyProvider.ResolvePackagesPath(null, null); 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 }); }
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"); }
public bool Execute() { // 1. Walk the graph of library dependencies var root = LibraryDependencyFinder.Build(_libraryManager.GetLibraryDescriptions(), _options.Project); if (_options.Mismatched) { RenderMismatchedDependencies(root); return(true); } if (!_options.ShowAssemblies) { RenderAllDependencies(root); return(true); } var assemblyPaths = PackageDependencyProvider.ResolvePackageAssemblyPaths(_libraryManager.GetLibraryDescriptions()); // 2. Walk the local dependencies and print the assemblies list var assemblyWalker = new AssemblyWalker(_framework, assemblyPaths, _options.RuntimeFolder, _options.Details, _options.Reports); assemblyWalker.Walk(root); return(true); }
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); }
private IEnumerable <LibraryAsset> PopulateAssets(TargetLibraryWithAssets library, IEnumerable <LockFileItem> section) { foreach (var assemblyPath in section.Where(a => !PackageDependencyProvider.IsPlaceholderFile(a.Path))) { yield return(LibraryAsset.CreateFromRelativePath(library.Path, assemblyPath.Path)); } }
private void ScanLibraries(LockFileTarget target, LockFileLookup lockFileLookup, Dictionary <LibraryKey, LibraryDescription> libraries, MSBuildDependencyProvider msbuildResolver, PackageDependencyProvider packageResolver, ProjectDependencyProvider projectResolver) { foreach (var library in target.Libraries) { LibraryDescription description = null; var type = LibraryType.Unspecified; if (string.Equals(library.Type, "project")) { var projectLibrary = lockFileLookup.GetProject(library.Name); if (projectLibrary != null) { if (MSBuildDependencyProvider.IsMSBuildProjectLibrary(projectLibrary)) { description = msbuildResolver.GetDescription(TargetFramework, projectLibrary, library, IsDesignTime); type = LibraryType.MSBuildProject; } else { var path = Path.GetFullPath(Path.Combine(ProjectDirectory, projectLibrary.Path)); description = projectResolver.GetDescription(library.Name, path, library, ProjectResolver); type = LibraryType.Project; } } } else { var packageEntry = lockFileLookup.GetPackage(library.Name, library.Version); if (packageEntry != null) { description = packageResolver.GetDescription(TargetFramework, packageEntry, library); } type = LibraryType.Package; } description = description ?? UnresolvedDependencyProvider.GetDescription(new LibraryRange(library.Name, type), target.TargetFramework); var lKey = new LibraryKey(library.Name); if (!libraries.ContainsKey(lKey)) { libraries.Add(lKey, description); } else { Console.WriteLine($"Dupe: {library.Name}"); } } }
private IEnumerable <LibraryResourceAssembly> PopulateResources(TargetLibraryWithAssets library, IEnumerable <LockFileItem> section) { foreach (var assemblyPath in section.Where(a => !PackageDependencyProvider.IsPlaceholderFile(a.Path))) { if (!assemblyPath.Properties.TryGetValue(Constants.LocaleLockFilePropertyName, out var locale)) { locale = null; } yield return(new LibraryResourceAssembly( LibraryAsset.CreateFromRelativePath(library.Path, assemblyPath.Path), locale)); } }
private void PopulateMetadataReferences(PackageDescription package, IDictionary <string, IMetadataReference> paths) { foreach (var assemblyPath in package.Target.CompileTimeAssemblies) { if (PackageDependencyProvider.IsPlaceholderFile(assemblyPath)) { continue; } var name = Path.GetFileNameWithoutExtension(assemblyPath); var path = Path.Combine(package.Path, assemblyPath); paths[name] = new MetadataFileReference(name, path); } }
public RuntimeLoadContext(string friendlyName, IEnumerable <LibraryDescription> libraries, ICompilationEngine compilationEngine, IAssemblyLoadContext defaultContext) : base(friendlyName) { // TODO: Make this all lazy // TODO: Unify this logic with default host var projects = libraries.Where(p => p.Type == LibraryTypes.Project) .OfType <ProjectDescription>(); var assemblies = PackageDependencyProvider.ResolvePackageAssemblyPaths(libraries); _projectAssemblyLoader = new ProjectAssemblyLoader(loadContextAccessor: null, compilationEngine: compilationEngine, projects: projects); _packageAssemblyLoader = new PackageAssemblyLoader(loadContextAccessor: null, assemblies: assemblies, libraryDescriptions: libraries); _defaultContext = defaultContext; }
internal void AddCompiler(string compilerDirectory) { DebugMessage("EdgeAssemblyLoadContext::AddCompiler (CLR) - Adding the compiler in {0}", compilerDirectory); ApplicationHostContext compilerHostContext = new ApplicationHostContext { ProjectDirectory = compilerDirectory, TargetFramework = TargetFrameworkName }; IList <LibraryDescription> libraries = ApplicationHostContext.GetRuntimeLibraries(compilerHostContext); Dictionary <AssemblyName, string> assemblies = PackageDependencyProvider.ResolvePackageAssemblyPaths(libraries); _loaders.Add(new PackageAssemblyLoader(_loadContextAccessor, assemblies, libraries)); DebugMessage("EdgeAssemblyLoadContext::AddCompiler (CLR) - Finished"); }
public EdgeAssemblyLoadContext(EdgeAssemblyLoadContextAccessor loadContextAccessor) { DebugMessage("EdgeAssemblyLoadContext::ctor (CLR) - Starting"); DebugMessage("EdgeAssemblyLoadContext::ctor (CLR) - Application root is {0}", RuntimeEnvironment.ApplicationDirectory); _loadContextAccessor = loadContextAccessor; if (File.Exists(Path.Combine(RuntimeEnvironment.ApplicationDirectory, "project.lock.json"))) { IList <LibraryDescription> libraries = ApplicationHostContext.GetRuntimeLibraries(ApplicationHostContext); Dictionary <string, ProjectDescription> projects = libraries.Where(p => p.Type == LibraryTypes.Project).ToDictionary(p => p.Identity.Name, p => (ProjectDescription)p); Dictionary <AssemblyName, string> assemblies = PackageDependencyProvider.ResolvePackageAssemblyPaths(libraries); CompilationEngineContext compilationContext = new CompilationEngineContext(ApplicationEnvironment, RuntimeEnvironment, this, new CompilationCache()); CompilationEngine compilationEngine = new CompilationEngine(compilationContext); AddCompileAssemblies(libraries); _loaders.Add(new ProjectAssemblyLoader(_loadContextAccessor, compilationEngine, projects.Values)); _loaders.Add(new PackageAssemblyLoader(_loadContextAccessor, assemblies, libraries)); } else { _noProjectJsonFile = true; if (File.Exists(Path.Combine(RuntimeEnvironment.EdgeNodePath, "project.lock.json"))) { ApplicationHostContext stockHostContext = new ApplicationHostContext { ProjectDirectory = RuntimeEnvironment.EdgeNodePath, TargetFramework = TargetFrameworkName }; IList <LibraryDescription> libraries = ApplicationHostContext.GetRuntimeLibraries(stockHostContext); Dictionary <AssemblyName, string> assemblies = PackageDependencyProvider.ResolvePackageAssemblyPaths(libraries); AddCompileAssemblies(libraries); _loaders.Add(new PackageAssemblyLoader(_loadContextAccessor, assemblies, libraries)); } } DebugMessage("EdgeAssemblyLoadContext::ctor (CLR) - Created the dependency providers for the application"); }
public void HasCompileTimePlaceholderReturnsFalseIfEmpty() { var provider = new PackageDependencyProvider("/foo/packages", new FrameworkReferenceResolver("/foo/references")); var package = new LockFilePackageLibrary(); package.Name = "Something"; package.Version = NuGetVersion.Parse("1.0.0"); var target = new LockFileTargetLibrary(); target.Name = "Something"; target.Version = package.Version; var p1 = provider.GetDescription(NuGetFramework.Parse("net46"), package, target); Assert.False(p1.HasCompileTimePlaceholder); Assert.Equal(0, p1.CompileTimeAssemblies.Count()); Assert.Equal(0, p1.RuntimeAssemblies.Count()); }
public EdgeAssemblyLoadContext(EdgeAssemblyLoadContextAccessor loadContextAccessor) { DebugMessage("EdgeAssemblyLoadContext::ctor (CLR) - Starting"); DebugMessage("EdgeAssemblyLoadContext::ctor (CLR) - Application root is {0}", RuntimeEnvironment.ApplicationDirectory); _loadContextAccessor = loadContextAccessor; if (File.Exists(Path.Combine(RuntimeEnvironment.ApplicationDirectory, "project.lock.json"))) { IList <LibraryDescription> libraries = ApplicationHostContext.GetRuntimeLibraries(ApplicationHostContext); Dictionary <string, ProjectDescription> projects = libraries.Where(p => p.Type == LibraryTypes.Project).ToDictionary(p => p.Identity.Name, p => (ProjectDescription)p); Dictionary <AssemblyName, string> assemblies = PackageDependencyProvider.ResolvePackageAssemblyPaths(libraries); CompilationEngineContext compilationContext = new CompilationEngineContext(ApplicationEnvironment, RuntimeEnvironment, this, new CompilationCache()); CompilationEngine compilationEngine = new CompilationEngine(compilationContext); foreach (LibraryDescription libraryDescription in libraries.Where(l => l.Type == LibraryTypes.Package)) { PackageDescription packageDescription = (PackageDescription)libraryDescription; if (packageDescription.Target.CompileTimeAssemblies != null && packageDescription.Target.CompileTimeAssemblies.Count > 0) { CompileAssemblies[libraryDescription.Identity.Name] = Path.Combine(packageDescription.Path, packageDescription.Target.CompileTimeAssemblies[0].Path); } else { CompileAssemblies[libraryDescription.Identity.Name] = Path.Combine(packageDescription.Path, packageDescription.Target.RuntimeAssemblies[0].Path); } } _loaders.Add(new ProjectAssemblyLoader(_loadContextAccessor, compilationEngine, projects.Values)); _loaders.Add(new PackageAssemblyLoader(_loadContextAccessor, assemblies, libraries)); } else { _noProjectJsonFile = true; } DebugMessage("EdgeAssemblyLoadContext::ctor (CLR) - Created the dependency providers for the application"); }
protected DotnetEf(string targetProject, ITestOutputHelper output, string startupProject = null) : base(new Muxer().MuxerPath, output) { _startupArgs = startupProject != null ? new[] { "--startup-project", startupProject } : Array.Empty <string>(); // always executes on startup project WorkingDirectory = Path.GetDirectoryName(targetProject); var rootDirectory = ProjectRootResolver.ResolveRootDirectory(WorkingDirectory); GlobalSettings globalSettings; GlobalSettings.TryGetGlobalSettings(rootDirectory, out globalSettings); rootDirectory = globalSettings?.DirectoryPath ?? rootDirectory; _nugetPackageDir = PackageDependencyProvider.ResolvePackagesPath(rootDirectory, globalSettings); var appName = GetType().GetTypeInfo().Assembly.GetName().Name; _runtimeConfig = Path.Combine(AppContext.BaseDirectory, appName + FileNameSuffixes.RuntimeConfigJson); _depsJson = Path.Combine(AppContext.BaseDirectory, appName + FileNameSuffixes.DepsJson); }
public ProjectContext Build() { var diagnostics = new List <DiagnosticMessage>(); ProjectDirectory = Project?.ProjectDirectory ?? ProjectDirectory; GlobalSettings globalSettings = null; if (ProjectDirectory != null) { RootDirectory = ProjectRootResolver.ResolveRootDirectory(ProjectDirectory); GlobalSettings.TryGetGlobalSettings(RootDirectory, out globalSettings); } RootDirectory = globalSettings?.DirectoryPath ?? RootDirectory; PackagesDirectory = PackagesDirectory ?? PackageDependencyProvider.ResolvePackagesPath(RootDirectory, globalSettings); FrameworkReferenceResolver frameworkReferenceResolver; if (string.IsNullOrEmpty(ReferenceAssembliesPath)) { // Use the default static resolver frameworkReferenceResolver = FrameworkReferenceResolver.Default; } else { frameworkReferenceResolver = new FrameworkReferenceResolver(ReferenceAssembliesPath); } LockFileLookup lockFileLookup = null; EnsureProjectLoaded(); ReadLockFile(diagnostics); var validLockFile = true; string lockFileValidationMessage = null; if (LockFile != null) { if (Project != null) { validLockFile = LockFile.IsValidForProject(Project, out lockFileValidationMessage); } lockFileLookup = new LockFileLookup(LockFile); } var libraries = new Dictionary <LibraryKey, LibraryDescription>(); var projectResolver = new ProjectDependencyProvider(ProjectResolver); ProjectDescription mainProject = null; if (Project != null) { mainProject = projectResolver.GetDescription(TargetFramework, Project, targetLibrary: null); // Add the main project libraries.Add(new LibraryKey(mainProject.Identity.Name), mainProject); } LibraryRange?platformDependency = null; if (mainProject != null) { platformDependency = mainProject.Dependencies .Where(d => d.Type.Equals(LibraryDependencyType.Platform)) .Cast <LibraryRange?>() .FirstOrDefault(); } bool isPortable = platformDependency != null; LockFileTarget target = null; LibraryDescription platformLibrary = null; if (lockFileLookup != null) { target = SelectTarget(LockFile, isPortable); if (target != null) { var nugetPackageResolver = new PackageDependencyProvider(PackagesDirectory, frameworkReferenceResolver); var msbuildProjectResolver = new MSBuildDependencyProvider(Project, ProjectResolver); ScanLibraries(target, lockFileLookup, libraries, msbuildProjectResolver, nugetPackageResolver, projectResolver); if (platformDependency != null) { libraries.TryGetValue(new LibraryKey(platformDependency.Value.Name), out platformLibrary); } } } string runtime = target?.RuntimeIdentifier; if (string.IsNullOrEmpty(runtime) && TargetFramework.IsDesktop()) { // we got a ridless target for desktop so turning portable mode on isPortable = true; var legacyRuntime = RuntimeEnvironmentRidExtensions.GetLegacyRestoreRuntimeIdentifier(); if (RuntimeIdentifiers.Contains(legacyRuntime)) { runtime = legacyRuntime; } else { runtime = RuntimeIdentifiers.FirstOrDefault(); } } var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(frameworkReferenceResolver); bool requiresFrameworkAssemblies; // Resolve the dependencies ResolveDependencies(libraries, referenceAssemblyDependencyResolver, out requiresFrameworkAssemblies); // 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 (frameworkReferenceResolver == null || string.IsNullOrEmpty(frameworkReferenceResolver.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 )); } } List <DiagnosticMessage> allDiagnostics = new List <DiagnosticMessage>(diagnostics); if (Project != null) { allDiagnostics.AddRange(Project.Diagnostics); } // Create a library manager var libraryManager = new LibraryManager(libraries.Values.ToList(), allDiagnostics, Project?.ProjectFilePath); return(new ProjectContext( globalSettings, mainProject, platformLibrary, TargetFramework, isPortable, runtime, PackagesDirectory, libraryManager, LockFile, diagnostics)); }
private void ScanLibraries(LockFileTarget target, LockFileLookup lockFileLookup, Dictionary <LibraryKey, LibraryDescription> libraries, PackageDependencyProvider packageResolver, ProjectDependencyProvider projectDependencyProvider) { foreach (var library in target.Libraries) { LibraryDescription description = null; var type = LibraryType.Unspecified; if (string.Equals(library.Type, "project")) { var projectLibrary = lockFileLookup.GetProject(library.Name); if (projectLibrary != null) { var path = Path.GetFullPath(Path.Combine(ProjectDirectory, projectLibrary.Path)); description = projectDependencyProvider.GetDescription(library.Name, path, library, ProjectResolver); } type = LibraryType.Project; } else { var packageEntry = lockFileLookup.GetPackage(library.Name, library.Version); if (packageEntry != null) { description = packageResolver.GetDescription(packageEntry, library); } type = LibraryType.Package; } description = description ?? UnresolvedDependencyProvider.GetDescription(new LibraryRange(library.Name, type), target.TargetFramework); libraries.Add(new LibraryKey(library.Name), description); } }
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(); LockFile = LockFile ?? LockFileResolver(ProjectDirectory); 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(Settings); 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 LibrariesAreResolvedCorrectly(string packageName, string framework, bool resolved) { var net45Target = new LockFileTarget { TargetFramework = new FrameworkName(".NETFramework,Version=v4.5"), Libraries = new List <LockFileTargetLibrary> { new LockFileTargetLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List <LockFileItem> { Path.Combine("ref", "net45", "_._") }, RuntimeAssemblies = new List <LockFileItem> { Path.Combine("lib", "net45", "_._") } } } }; var dnx451Target = new LockFileTarget { TargetFramework = new FrameworkName("DNX,Version=v4.5.1"), Libraries = new List <LockFileTargetLibrary> { new LockFileTargetLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0") }, new LockFileTargetLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List <LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") }, RuntimeAssemblies = new List <LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") } }, new LockFileTargetLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List <LockFileItem> { Path.Combine("ref", "net451", "Net451LibPackage.dll") } }, new LockFileTargetLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0") } } }; var metaPackageLibrary = new LockFilePackageLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0") }; var net451LibPackageLibrary = new LockFilePackageLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List <string> { Path.Combine("lib", "net451", "Net451LibPackage.dll"), Path.Combine("lib", "net451", "Net451LibPackage.xml") } }; var net451RefPackageLibrary = new LockFilePackageLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List <string> { Path.Combine("ref", "net451", "Net451LibPackage.dll") } }; var assemblyPlaceholderPackageLibrary = new LockFilePackageLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List <string> { Path.Combine("lib", "net45", "_._"), Path.Combine("ref", "net45", "_._"), } }; var lockFile = new LockFile() { Targets = new List <LockFileTarget> { net45Target, dnx451Target }, PackageLibraries = new List <LockFilePackageLibrary> { metaPackageLibrary, net451LibPackageLibrary, net451RefPackageLibrary, assemblyPlaceholderPackageLibrary } }; var resolver = new PackageDependencyProvider("/path/to/packages"); var lockFileLookup = new LockFileLookup(lockFile); var targetFramework = new FrameworkName(framework); var libToLookup = lockFile.Targets.First(t => t.TargetFramework == targetFramework) .Libraries .First(l => l.Name == packageName); var description = resolver.GetDescription(lockFileLookup.GetPackage(libToLookup.Name, libToLookup.Version), libToLookup); Assert.Equal(resolved, description.Compatible); Assert.NotNull(description); }
public void LibrariesAreResolvedCorrectly(string packageName, string framework, bool resolved) { var net45Target = new LockFileTarget { TargetFramework = new FrameworkName(".NETFramework,Version=v4.5"), Libraries = new List<LockFileTargetLibrary> { new LockFileTargetLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("ref", "net45", "_._") }, RuntimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net45", "_._") } } } }; var dnx451Target = new LockFileTarget { TargetFramework = new FrameworkName("DNX,Version=v4.5.1"), Libraries = new List<LockFileTargetLibrary> { new LockFileTargetLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0") }, new LockFileTargetLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") }, RuntimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") } }, new LockFileTargetLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("ref", "net451", "Net451LibPackage.dll") } }, new LockFileTargetLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0") } } }; var metaPackageLibrary = new LockFilePackageLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0") }; var net451LibPackageLibrary = new LockFilePackageLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List<string> { Path.Combine("lib", "net451", "Net451LibPackage.dll"), Path.Combine("lib", "net451", "Net451LibPackage.xml") } }; var net451RefPackageLibrary = new LockFilePackageLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List<string> { Path.Combine("ref", "net451", "Net451LibPackage.dll") } }; var assemblyPlaceholderPackageLibrary = new LockFilePackageLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List<string> { Path.Combine("lib", "net45", "_._"), Path.Combine("ref", "net45", "_._"), } }; var lockFile = new LockFile() { Targets = new List<LockFileTarget> { net45Target, dnx451Target }, PackageLibraries = new List<LockFilePackageLibrary> { metaPackageLibrary, net451LibPackageLibrary, net451RefPackageLibrary, assemblyPlaceholderPackageLibrary } }; var resolver = new PackageDependencyProvider("/path/to/packages"); var lockFileLookup = new LockFileLookup(lockFile); var targetFramework = new FrameworkName(framework); var libToLookup = lockFile.Targets.First(t => t.TargetFramework == targetFramework) .Libraries .First(l => l.Name == packageName); var description = resolver.GetDescription(lockFileLookup.GetPackage(libToLookup.Name, libToLookup.Version), libToLookup); Assert.Equal(resolved, description.Compatible); Assert.NotNull(description); }
private void Initialize(DefaultHostOptions options, IAssemblyLoadContextAccessor loadContextAccessor) { var applicationHostContext = new ApplicationHostContext { ProjectDirectory = _projectDirectory, RuntimeIdentifiers = _runtimeEnvironment.GetAllRuntimeIdentifiers(), TargetFramework = _targetFramework }; var libraries = ApplicationHostContext.GetRuntimeLibraries(applicationHostContext, throwOnInvalidLockFile: true); Logger.TraceInformation("[{0}]: Project path: {1}", GetType().Name, applicationHostContext.ProjectDirectory); Logger.TraceInformation("[{0}]: Project root: {1}", GetType().Name, applicationHostContext.RootDirectory); Logger.TraceInformation("[{0}]: Project configuration: {1}", GetType().Name, options.Configuration); Logger.TraceInformation("[{0}]: Packages path: {1}", GetType().Name, applicationHostContext.PackagesDirectory); _applicationHostContext = applicationHostContext; _project = applicationHostContext.Project; #if FEATURE_DNX_MIN_VERSION_CHECK ValidateMinRuntimeVersion(libraries); #endif // Create a new Application Environment for running the app. It needs a reference to the Host's application environment // (if any), which we can get from the service provider we were given. // If this is null (i.e. there is no Host Application Environment), that's OK, the Application Environment we are creating // will just have it's own independent set of global data. var hostEnvironment = PlatformServices.Default.Application; var applicationEnvironment = new ApplicationEnvironment(Project, _targetFramework, hostEnvironment); var compilationContext = new CompilationEngineContext( applicationEnvironment, _runtimeEnvironment, loadContextAccessor.Default, new CompilationCache()); var compilationEngine = new CompilationEngine(compilationContext); var runtimeLibraryExporter = new RuntimeLibraryExporter(() => compilationEngine.CreateProjectExporter(Project, _targetFramework, options.Configuration)); var runtimeLibraryManager = new RuntimeLibraryManager(applicationHostContext); // Default services _serviceProvider.Add(typeof(ILibraryExporter), runtimeLibraryExporter); _serviceProvider.Add(typeof(IApplicationEnvironment), applicationEnvironment); _serviceProvider.Add(typeof(IRuntimeEnvironment), PlatformServices.Default.Runtime); _serviceProvider.Add(typeof(ILibraryManager), runtimeLibraryManager); _serviceProvider.Add(typeof(IAssemblyLoadContextAccessor), PlatformServices.Default.AssemblyLoadContextAccessor); _serviceProvider.Add(typeof(IAssemblyLoaderContainer), PlatformServices.Default.AssemblyLoaderContainer); PlatformServices.SetDefault(new ApplicationHostPlatformServices(PlatformServices.Default, applicationEnvironment, runtimeLibraryManager)); if (options.CompilationServerPort.HasValue) { // Change the project reference provider Project.DefaultCompiler = Project.DefaultDesignTimeCompiler; Project.DesignTimeCompilerPort = options.CompilationServerPort.Value; } // TODO: Dedupe this logic in the RuntimeLoadContext var projects = libraries.Where(p => p.Type == Runtime.LibraryTypes.Project) .ToDictionary(p => p.Identity.Name, p => (ProjectDescription)p); var assemblies = PackageDependencyProvider.ResolvePackageAssemblyPaths(libraries); // Configure Assembly loaders _loaders.Add(new ProjectAssemblyLoader(loadContextAccessor, compilationEngine, projects.Values, options.Configuration)); _loaders.Add(new PackageAssemblyLoader(loadContextAccessor, assemblies, libraries)); var compilerOptionsProvider = new CompilerOptionsProvider(projects); _serviceProvider.Add(typeof(ICompilerOptionsProvider), compilerOptionsProvider); CompilationServices.SetDefault( CompilationServices.Create( libraryExporter: runtimeLibraryExporter, compilerOptionsProvider: compilerOptionsProvider ) ); #if DNX451 PackageDependencyProvider.EnableLoadingNativeLibraries(libraries); #endif AddBreadcrumbs(libraries); }
private static IEnumerable <LockFileItem> FilterPlaceholders(IEnumerable <LockFileItem> items) { return(items.Where(a => !PackageDependencyProvider.IsPlaceholderFile(a))); }
private void Initialize(RuntimeOptions options, IServiceProvider hostServices, IAssemblyLoadContextAccessor loadContextAccessor, IFileWatcher fileWatcher) { var applicationHostContext = new ApplicationHostContext { ProjectDirectory = _projectDirectory, RuntimeIdentifiers = _runtimeEnvironment.GetAllRuntimeIdentifiers(), TargetFramework = _targetFramework }; var libraries = ApplicationHostContext.GetRuntimeLibraries(applicationHostContext, throwOnInvalidLockFile: true); Logger.TraceInformation("[{0}]: Project path: {1}", GetType().Name, applicationHostContext.ProjectDirectory); Logger.TraceInformation("[{0}]: Project root: {1}", GetType().Name, applicationHostContext.RootDirectory); Logger.TraceInformation("[{0}]: Project configuration: {1}", GetType().Name, options.Configuration); Logger.TraceInformation("[{0}]: Packages path: {1}", GetType().Name, applicationHostContext.PackagesDirectory); _applicationHostContext = applicationHostContext; _project = applicationHostContext.Project; ValidateMinRuntimeVersion(libraries); if (options.WatchFiles) { fileWatcher.OnChanged += _ => { _shutdown.RequestShutdownWaitForDebugger(); }; } // Create a new Application Environment for running the app. It needs a reference to the Host's application environment // (if any), which we can get from the service provider we were given. // If this is null (i.e. there is no Host Application Environment), that's OK, the Application Environment we are creating // will just have it's own independent set of global data. var hostEnvironment = (IApplicationEnvironment)hostServices.GetService(typeof(IApplicationEnvironment)); var applicationEnvironment = new ApplicationEnvironment(Project, _targetFramework, options.Configuration, hostEnvironment); var compilationContext = new CompilationEngineContext( applicationEnvironment, _runtimeEnvironment, loadContextAccessor.Default, new CompilationCache(), fileWatcher); // Compilation services available only for runtime compilation compilationContext.AddCompilationService(typeof(RuntimeOptions), options); compilationContext.AddCompilationService(typeof(IApplicationShutdown), _shutdown); var compilationEngine = new CompilationEngine(compilationContext); // Default services _serviceProvider.Add(typeof(IApplicationEnvironment), applicationEnvironment); _serviceProvider.Add(typeof(ILibraryManager), new RuntimeLibraryManager(applicationHostContext)); _serviceProvider.Add(typeof(ILibraryExporter), new RuntimeLibraryExporter(() => compilationEngine.CreateProjectExporter(Project, _targetFramework, options.Configuration))); _serviceProvider.Add(typeof(IApplicationShutdown), _shutdown); if (options.CompilationServerPort.HasValue) { // Change the project reference provider Project.DefaultCompiler = Project.DefaultDesignTimeCompiler; } CallContextServiceLocator.Locator.ServiceProvider = ServiceProvider; // TODO: Dedupe this logic in the RuntimeLoadContext var projects = libraries.Where(p => p.Type == LibraryTypes.Project) .ToDictionary(p => p.Identity.Name, p => (ProjectDescription)p); var assemblies = PackageDependencyProvider.ResolvePackageAssemblyPaths(libraries); // Configure Assembly loaders _loaders.Add(new ProjectAssemblyLoader(loadContextAccessor, compilationEngine, projects.Values)); _loaders.Add(new PackageAssemblyLoader(loadContextAccessor, assemblies)); _serviceProvider.Add(typeof(ICompilerOptionsProvider), new CompilerOptionsProvider(projects)); AddBreadcrumbs(libraries); }
private LibraryExport ExportPackage(TargetLibraryWithAssets library) { var builder = LibraryExportBuilder.Create(library); builder.AddNativeLibraryGroup(new LibraryAssetGroup(PopulateAssets(library, library.NativeLibraries))); builder.AddRuntimeAssemblyGroup(new LibraryAssetGroup(PopulateAssets(library, library.RuntimeAssemblies))); builder.WithResourceAssemblies(PopulateResources(library, library.ResourceAssemblies)); builder.WithCompilationAssemblies(PopulateAssets(library, library.CompileTimeAssemblies)); if (library.Identity.Type.Equals(LibraryType.Package)) { builder.WithSourceReferences(GetSharedSources((PackageDescription)library)); builder.WithAnalyzerReference(GetAnalyzerReferences((PackageDescription)library)); } if (library.ContentFiles.Any()) { var parameters = PPFileParameters.CreateForProject(_rootProject.Project); Action <Stream, Stream> transform = (input, output) => PPFilePreprocessor.Preprocess(input, output, parameters); var sourceCodeLanguage = _rootProject.Project.GetSourceCodeLanguage(); var languageGroups = library.ContentFiles.GroupBy(file => file.CodeLanguage); var selectedGroup = languageGroups.FirstOrDefault(g => g.Key == sourceCodeLanguage) ?? languageGroups.FirstOrDefault(g => g.Key == null); if (selectedGroup != null) { foreach (var contentFile in selectedGroup) { if (contentFile.CodeLanguage != null && string.Compare(contentFile.CodeLanguage, sourceCodeLanguage, StringComparison.OrdinalIgnoreCase) != 0) { continue; } var fileTransform = contentFile.PPOutputPath != null ? transform : null; var fullPath = Path.Combine(library.Path, contentFile.Path); if (contentFile.BuildAction == BuildAction.Compile) { builder.AddSourceReference(LibraryAsset.CreateFromRelativePath(library.Path, contentFile.Path, fileTransform)); } else if (contentFile.BuildAction == BuildAction.EmbeddedResource) { builder.AddEmbedddedResource(LibraryAsset.CreateFromRelativePath(library.Path, contentFile.Path, fileTransform)); } if (contentFile.CopyToOutput) { builder.AddRuntimeAsset(new LibraryAsset(contentFile.Path, contentFile.OutputPath, fullPath, fileTransform)); } } } } if (library.RuntimeTargets.Any()) { foreach (var targetGroup in library.RuntimeTargets.GroupBy(t => t.Runtime)) { var runtime = new List <LibraryAsset>(); var native = new List <LibraryAsset>(); foreach (var lockFileRuntimeTarget in targetGroup) { if (string.Equals(lockFileRuntimeTarget.AssetType, "native", StringComparison.OrdinalIgnoreCase)) { native.Add(LibraryAsset.CreateFromRelativePath(library.Path, lockFileRuntimeTarget.Path)); } else if (string.Equals(lockFileRuntimeTarget.AssetType, "runtime", StringComparison.OrdinalIgnoreCase)) { runtime.Add(LibraryAsset.CreateFromRelativePath(library.Path, lockFileRuntimeTarget.Path)); } } if (runtime.Any()) { builder.AddRuntimeAssemblyGroup(new LibraryAssetGroup(targetGroup.Key, runtime.Where(a => !PackageDependencyProvider.IsPlaceholderFile(a.RelativePath)))); } if (native.Any()) { builder.AddNativeLibraryGroup(new LibraryAssetGroup(targetGroup.Key, native.Where(a => !PackageDependencyProvider.IsPlaceholderFile(a.RelativePath)))); } } } return(builder.Build()); }
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); }
public PackageAssemblyLoader(IAssemblyLoadContextAccessor loadContextAccessor, LibraryManager libraryManager) { _loadContextAccessor = loadContextAccessor; _assemblies = PackageDependencyProvider.ResolvePackageAssemblyPaths(libraryManager); }
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(); }