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));
}
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 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();
}
