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]; } }
private CommandSpec ResolveCommandSpecFromToolLibrary( LibraryRange toolLibrary, string commandName, IEnumerable <string> args, ProjectContext projectContext) { //todo: change this for new resolution strategy var lockFilePath = Path.Combine( projectContext.ProjectDirectory, "artifacts", "Tools", toolLibrary.Name, "project.lock.json"); if (!File.Exists(lockFilePath)) { return(null); } var lockFile = LockFileReader.Read(lockFilePath); var lockFilePackageLibrary = lockFile.PackageLibraries.FirstOrDefault(l => l.Name == toolLibrary.Name); var nugetPackagesRoot = projectContext.PackagesDirectory; return(_packagedCommandSpecFactory.CreateCommandSpecFromLibrary( lockFilePackageLibrary, commandName, args, _allowedCommandExtensions, projectContext.PackagesDirectory, s_commandResolutionStrategy, null)); }
public static CommandSpec ResolveFromProjectTools(string commandName, string args) { var context = GetProjectContext(FrameworkConstants.CommonFrameworks.DnxCore50); if (context == null) { return(null); } var commandLibrary = context.ProjectFile.Tools .FirstOrDefault(l => l.Name == commandName); if (commandLibrary == default(LibraryRange)) { return(null); } var lockPath = Path.Combine(context.ProjectDirectory, "artifacts", "Tools", commandName, "project.lock.json"); if (!File.Exists(lockPath)) { return(null); } var lockFile = LockFileReader.Read(lockPath); var lib = lockFile.PackageLibraries.FirstOrDefault(l => l.Name == commandName); var packageDir = new VersionFolderPathResolver(context.PackagesDirectory) .GetInstallPath(lib.Name, lib.Version); return(Directory.Exists(packageDir) ? ConfigureCommandFromPackage(commandName, args, lib.Files, packageDir) : null); }
public void TestMissingExportsUnderDesignTime() { var lockFilePath = GetLockFilePath("invalid_missing-exports"); // not throw under design time scenario Assert.NotNull(LockFileReader.Read(lockFilePath, designTime: true)); }
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); currentEntry.Model = LockFileReader.Read(currentEntry.FilePath); currentEntry.UpdateLastWriteTimeUtc(); } } return(currentEntry); }
public void Generate_deps_json_method_doesnt_overwrite_when_deps_file_already_exists() { var context = ProjectContext.Create(Path.Combine(s_liveProjectDirectory, "project.json"), s_toolPackageFramework); var nugetPackagesRoot = context.PackagesDirectory; var toolPathCalculator = new ToolPathCalculator(nugetPackagesRoot); var lockFilePath = toolPathCalculator.GetLockFilePath( "dotnet-portable", new NuGetVersion("1.0.0"), s_toolPackageFramework); var lockFile = LockFileReader.Read(lockFilePath, designTime: false); var depsJsonFile = Path.Combine( Path.GetDirectoryName(lockFilePath), "dotnet-portable.deps.json"); if (File.Exists(depsJsonFile)) { File.Delete(depsJsonFile); } File.WriteAllText(depsJsonFile, "temp"); var projectToolsCommandResolver = SetupProjectToolsCommandResolver(); projectToolsCommandResolver.GenerateDepsJsonFile(lockFile, depsJsonFile); File.ReadAllText(depsJsonFile).Should().Be("temp"); File.Delete(depsJsonFile); }
public LockFilePatcher(LockFile lockFile, LockFileReader reader) { _lockFile = lockFile; _reader = reader; var msbuildProjectLibraries = lockFile.ProjectLibraries.Where(MSBuildDependencyProvider.IsMSBuildProjectLibrary); _msbuildTargetLibraries = msbuildProjectLibraries.ToDictionary(GetProjectLibraryKey, l => GetTargetsForLibrary(_lockFile, l)); }
private static LockFile ResolveLockFile(string projectDir) { var projectLockJsonPath = Path.Combine(projectDir, LockFile.FileName); return(File.Exists(projectLockJsonPath) ? LockFileReader.Read(Path.Combine(projectDir, LockFile.FileName)) : null); }
public void TestPackageFoldersLoadCorrectly() { var lockFilePath = GetLockFilePath("valid"); var lockFile = LockFileReader.Read(lockFilePath, designTime: false); Assert.Equal(2, lockFile.PackageFolders.Count); Assert.Equal("/foo/packages", lockFile.PackageFolders[0].Path); Assert.Equal("/foo/packages2", lockFile.PackageFolders[1].Path); }
public void ReadsAllLibraryPropertiesWhenPathIsPresent() { // Arrange var lockFileJson = @" { ""libraries"": { ""PackageA/1.0.1-Alpha"": { ""sha512"": ""FAKE-HASH"", ""type"": ""package"", ""serviceable"": true, ""files"": [ ""a.txt"", ""foo/b.txt"" ], ""path"": ""PackageA/1.0.1-beta-PATH"" }, ""ProjectA/1.0.2-Beta"": { ""type"": ""project"", ""path"": ""ProjectA-PATH"", ""msbuildProject"": ""some-msbuild"" } } }"; var lockFileStream = new MemoryStream(Encoding.UTF8.GetBytes(lockFileJson)); var lockFileReader = new LockFileReader(); // Act var lockFile = lockFileReader.ReadLockFile( lockFilePath: null, stream: lockFileStream, designTime: true); // Assert lockFile.PackageLibraries.Should().HaveCount(1); var package = lockFile.PackageLibraries.First(); package.Name.Should().Be("PackageA"); package.Version.ToString().Should().Be("1.0.1-Alpha"); package.Sha512.Should().Be("FAKE-HASH"); package.IsServiceable.Should().BeTrue(); package.Files.Should().HaveCount(2); package.Files[0].Should().Be("a.txt"); package.Files[1].Should().Be(Path.Combine("foo", "b.txt")); package.Path.Should().Be("PackageA/1.0.1-beta-PATH"); lockFile.ProjectLibraries.Should().HaveCount(1); var project = lockFile.ProjectLibraries.First(); project.Name.Should().Be("ProjectA"); project.Version.ToString().Should().Be("1.0.2-Beta"); project.Path.Should().Be("ProjectA-PATH"); }
public static IEnumerable<Graph> FromProjectDirectory(string dir) { var projectFile = new ProjectReader().ReadProject( new FileStream(Path.Combine(dir, "project.json"), FileMode.Open), Path.GetFileName(dir), dir, new List<DiagnosticMessage>()); var lockFile = new LockFileReader().Read(Path.Combine(dir, "project.lock.json")); return lockFile.Targets.Select(t => ForTarget(projectFile, t)); }
public void TestFragmentExistsButNoHolesInLockFile() { var lockFilePath = GetLockFilePath("valid_staleFragment"); var lockFile = LockFileReader.Read(lockFilePath); var exportFile = lockFile.ExportFile; exportFile.Should().BeNull(); lockFile.Targets.Count.Should().Be(1); lockFile.Targets[0].Libraries.Count.Should().Be(0); }
public void TestLockFileIsPatchedWithExportData() { var lockFilePath = GetLockFilePath("valid"); var lockFile = LockFileReader.Read(lockFilePath); // check lock file structure is similar to export structure foreach (var target in lockFile.Targets) { target.Libraries.Count.Should().Be(3); foreach (var library in target.Libraries) { AssertTargetLibrary(library); } } }
public Project(ProjectModel.Project runtimeProject) { ProjectFile = runtimeProject.ProjectFilePath; ProjectDirectory = runtimeProject.ProjectDirectory; var compilerOptions = runtimeProject.GetCompilerOptions(targetFramework: null, configurationName: null); var filesToWatch = new List <string>() { runtimeProject.ProjectFilePath }; if (compilerOptions?.CompileInclude != null) { filesToWatch.AddRange(compilerOptions.CompileInclude.ResolveFiles()); } else { filesToWatch.AddRange(runtimeProject.Files.SourceFiles); } if (compilerOptions?.EmbedInclude != null) { filesToWatch.AddRange(compilerOptions.EmbedInclude.ResolveFiles()); } else { filesToWatch.AddRange(runtimeProject.Files.ResourceFiles.Values); } filesToWatch.AddRange(runtimeProject.Files.SharedFiles); filesToWatch.AddRange(runtimeProject.Files.PreprocessSourceFiles); Files = filesToWatch; 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 TestExportFileIsParsed() { var lockFilePath = GetLockFilePath("valid"); var lockFile = LockFileReader.Read(lockFilePath); 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>(); } 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); }
public static async Task Main(string[] args) { string testLockFile = $"/home/marco/workspace/dotnet-audit/samples/{PackagesLock}"; var dependencies = await LockFileReader.ReadDependencies(testLockFile); foreach (var dependency in dependencies) { Console.WriteLine($"{dependency.Name} ({dependency.Type.ToString()}) [{dependency.ResolvedVersion}]"); } var reports = await OssIndexReader.GetVulnerabilities(dependencies); foreach (var report in reports) { if (report.Vulnerabilities.Any()) { Console.WriteLine($"{report.Name}"); Console.WriteLine($"{report.Description}"); } } }
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 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 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)); }
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); }
protected Workspace(ProjectReaderSettings settings, bool designTime) { _settings = settings; _lockFileReader = new LockFileReader(); _designTime = designTime; }
public void GenerateBatchFilesAndBashScriptsWithPublishedRuntime(string flavor, string os, string architecture, string configuration) { var runtimeHomeDir = _fixture.GetRuntimeHomeDir(flavor, os, architecture); // Each runtime home only contains one runtime package, which is the one we are currently testing against var runtimeRoot = Directory.EnumerateDirectories(Path.Combine(runtimeHomeDir, "runtimes"), Constants.RuntimeNamePrefix + "*").First(); var runtimeName = new DirectoryInfo(runtimeRoot).Name; var projectStructure = @"{ '.': ['project.json'], 'packages': {} }"; var expectedOutputStructure = @"{ 'approot': { '.': ['run.cmd', 'run', 'kestrel.cmd', 'kestrel'], 'global.json': '', 'src': { 'PROJECT_NAME': { '.': ['project.json', 'project.lock.json'] } }, 'packages': {}, 'runtimes': { 'RUNTIME_PACKAGE_NAME': {} } } }".Replace("PROJECT_NAME", _projectName).Replace("RUNTIME_PACKAGE_NAME", runtimeName); using (var testEnv = new DnuTestEnvironment(runtimeHomeDir, _projectName, _outputDirName)) { DirTree.CreateFromJson(projectStructure) .WithFileContents("project.json", @"{ ""commands"": { ""run"": ""run server.urls=http://localhost:5003"", ""kestrel"": ""Microsoft.AspNet.Hosting --server Microsoft.AspNet.Server.Kestrel --server.urls http://localhost:5004"" }, ""frameworks"": { ""dnx451"": { }, ""dnxcore50"": { } } }") .WriteTo(testEnv.ProjectPath); var environment = new Dictionary<string, string>() { { EnvironmentNames.Packages, Path.Combine(testEnv.ProjectPath, "packages") }, { EnvironmentNames.Home, runtimeHomeDir }, { EnvironmentNames.Trace, "1" } }; var arguments = $"--out {testEnv.PublishOutputDirPath} --runtime {runtimeName}"; if (configuration != null) { arguments += $" --configuration {configuration}"; } else { // default value "Debug" is always set. this variable is used in verification later. configuration = "Debug"; } var exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, subcommand: "publish", arguments: arguments, environment: environment, workingDir: testEnv.ProjectPath); Assert.Equal(0, exitCode); var runtimeSubDir = DirTree.CreateFromDirectory(runtimeRoot) .RemoveFile(Path.Combine("bin", "lib", "Microsoft.Dnx.Tooling", "bin", "profile", "startup.prof")); var batchFileBinPath = string.Format(@"%~dp0runtimes\{0}\bin\", runtimeName); var bashScriptBinPath = string.Format("$DIR/runtimes/{0}/bin/", runtimeName); var expectedOutputDir = DirTree.CreateFromJson(expectedOutputStructure) .WithFileContents(Path.Combine("approot", "src", testEnv.ProjectName, "project.json"), @"{ ""commands"": { ""run"": ""run server.urls=http://localhost:5003"", ""kestrel"": ""Microsoft.AspNet.Hosting --server Microsoft.AspNet.Server.Kestrel --server.urls http://localhost:5004"" }, ""frameworks"": { ""dnx451"": { }, ""dnxcore50"": { } } }") .WithFileContents(Path.Combine("approot", "global.json"), @"{ ""projects"": [ ""src"" ], ""packages"": ""packages"" }") .WithFileContents(Path.Combine("approot", "run.cmd"), BatchFileTemplate, runtimeName, Constants.BootstrapperExeName, testEnv.ProjectName, configuration, "run") .WithFileContents(Path.Combine("approot", "kestrel.cmd"), BatchFileTemplate, runtimeName, Constants.BootstrapperExeName, testEnv.ProjectName, configuration, "kestrel") .WithFileContents(Path.Combine("approot", "run"), BashScriptTemplate, testEnv.ProjectName, bashScriptBinPath, Constants.BootstrapperExeName, configuration, "run") .WithFileContents(Path.Combine("approot", "kestrel"), BashScriptTemplate, testEnv.ProjectName, bashScriptBinPath, Constants.BootstrapperExeName, configuration, "kestrel") .WithSubDir(Path.Combine("approot", "runtimes", runtimeName), runtimeSubDir); Assert.True(expectedOutputDir.MatchDirectoryOnDisk(testEnv.PublishOutputDirPath, compareFileContents: true)); var lockFile = new LockFileReader().Read(Path.Combine(testEnv.PublishOutputDirPath, "approot", "src", testEnv.ProjectName, "project.lock.json")); var fx = flavor == "coreclr" ? DnxCore50 : Dnx451; Assert.True(lockFile.HasTarget(fx)); // GetRuntimeIdentifiers is tested separately, we're testing that the targets made the lock file here. var rids = Publish.DependencyContext.GetRuntimeIdentifiers(runtimeName); foreach(var rid in rids) { Assert.True(lockFile.HasTarget(fx, rid)); } } }
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 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 void TestMissingExportsThrow() { var lockFilePath = GetLockFilePath("invalid_missing-exports"); Assert.Throws <FileFormatException>(() => LockFileReader.Read(lockFilePath)); }
public void PublishMultipleProjectsWithDifferentTargetFrameworks(string flavor, string os, string architecture) { string projectStructure = @"{ 'App': [ 'project.json' ], 'Lib': [ 'project.json' ], '.': [ 'global.json' ] }"; var runtimeHomeDir = _fixture.GetRuntimeHomeDir(flavor, os, architecture); using (var testEnv = new DnuTestEnvironment(runtimeHomeDir, _projectName, _outputDirName)) { DirTree.CreateFromJson(projectStructure) .WithFileContents("global.json", @"{ ""projects"": [ ""."" ] }") .WithFileContents("App/project.json", @"{ ""dependencies"": { ""Lib"": """" }, ""frameworks"": { ""dnx46"": {} } }") .WithFileContents("Lib/project.json", @"{ ""frameworks"": { ""dnx451"": {} } }") .WriteTo(testEnv.ProjectPath); var environment = new Dictionary<string, string>() { { EnvironmentNames.Packages, Path.Combine(testEnv.ProjectPath, "packages") } }; var exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, subcommand: "restore", arguments: "", environment: environment, workingDir: testEnv.ProjectPath); Assert.Equal(0, exitCode); exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, subcommand: "publish", arguments: string.Format("--out {0}", testEnv.PublishOutputDirPath), environment: environment, workingDir: Path.Combine(testEnv.ProjectPath, "App")); Assert.Equal(0, exitCode); // App lock file has DNX 4.6 target referring to lib with DNX 4.5.1 target var appLockFile = new LockFileReader().Read(Path.Combine(testEnv.PublishOutputDirPath, "approot", "src", "App", "project.lock.json")); foreach(var target in appLockFile.Targets) { // Rid will differ Assert.Equal(Dnx46, target.TargetFramework); var lib = target.Libraries.FirstOrDefault(l => l.Name.Equals("Lib")); Assert.NotNull(lib); Assert.Equal("project", lib.Type); Assert.Equal(Dnx451, lib.TargetFramework); } // Lib lock file has DNX 4.5.1 target AssertDefaultTargets(Path.Combine(testEnv.PublishOutputDirPath, "approot", "src", "Lib", "project.lock.json"), Dnx451); } }
public void TestMissingExportFileThrows() { var lockFilePath = GetLockFilePath("invalid_nofragment"); Assert.Throws <FileFormatException>(() => LockFileReader.Read(lockFilePath)); }
private static void AssertDefaultTargets(string lockFilePath, FrameworkName framework) { var lockFile = new LockFileReader().Read(lockFilePath); Assert.True(lockFile.HasTarget(framework)); foreach(var rid in PlatformServices.Default.Runtime.GetDefaultRestoreRuntimes()) { Assert.True(lockFile.HasTarget(framework, rid)); } }
public void TestMissmatchingFileVersionsThrows() { var lockFilePath = GetLockFilePath("invalid_missmatching-versions"); Assert.Throws <FileFormatException>(() => LockFileReader.Read(lockFilePath)); }
public void TestMissmatchingFileVersionsUnderDesignTime() { var lockFilePath = GetLockFilePath("invalid_missmatching-versions"); Assert.NotNull(LockFileReader.Read(lockFilePath, designTime: true)); }
public void PublishWithNoSourceOptionUpdatesLockFileOnClr(string flavor, string os, string architecture) { const string testApp = "NoDependencies"; string expectedOutputStructure = @"{ 'approot': { '.': ['hello', 'hello.cmd'], 'global.json': '', 'packages': { 'NoDependencies': { '1.0.0': { '.': ['NoDependencies.1.0.0.nupkg', 'NoDependencies.1.0.0.nupkg.sha512', 'NoDependencies.nuspec'], 'app': ['hello', 'hello.cmd', 'project.json'], 'root': ['project.json', 'project.lock.json'], 'lib': { 'dnx451': ['NoDependencies.dll', 'NoDependencies.xml'] } } } } } }"; var runtimeHomeDir = _fixture.GetRuntimeHomeDir(flavor, os, architecture); using (var tempDir = new DisposableDir()) { var publishOutputPath = Path.Combine(tempDir, "output"); var appPath = Path.Combine(tempDir, testApp); TestUtils.CopyFolder(TestUtils.GetXreTestAppPath(testApp), appPath); // Generate lockfile for the HelloWorld app var exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, subcommand: "restore", arguments: string.Empty, environment: null, workingDir: appPath); Assert.Equal(0, exitCode); exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, subcommand: "publish", arguments: string.Format("--no-source --out {0}", publishOutputPath), environment: null, workingDir: appPath); Assert.Equal(0, exitCode); Assert.True(DirTree.CreateFromJson(expectedOutputStructure) .MatchDirectoryOnDisk(publishOutputPath, compareFileContents: false)); var outputLockFilePath = Path.Combine(publishOutputPath, "approot", "packages", testApp, "1.0.0", "root", LockFileFormat.LockFileName); var lockFile = new LockFileReader().Read(outputLockFilePath); Assert.True(lockFile.PackageLibraries.Any(p => p.Name.Equals("NoDependencies"))); } }
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(); }