private void WriteGlobalJson()
{
var rootDirectory = ProjectResolver.ResolveRootDirectory(_project.ProjectDirectory);
var rootObject = default(JObject);
if (GlobalSettings.HasGlobalFile(rootDirectory))
{
rootObject = JObject.Parse(File.ReadAllText(Path.Combine(
rootDirectory,
GlobalSettings.GlobalFileName)));
}
else
{
rootObject = new JObject();
}
var applicationRoot = Path.Combine(OutputPath, PublishRoot.AppRootName);
rootObject["packages"] = PathUtility.GetRelativePath(
PathUtility.EnsureTrailingForwardSlash(applicationRoot),
TargetPackagesPath, separator: '/');
File.WriteAllText(Path.Combine(applicationRoot, GlobalSettings.GlobalFileName),
rootObject.ToString());
}
public void BuildPackageAndCheckServiceability(string projectName, bool expectedServiceability)
{
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var projectSrcDir = Path.Combine(rootDir, "misc", "ServicingTestProjects", projectName);
const string configuration = "Debug";
var components = TestUtils.GetRuntimeComponentsCombinations().First();
var flavor = (string)components[0];
var os = (string)components[1];
var architecture = (string)components[2];
using (var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture))
using (var tempDir = new DisposableDir())
{
var projectDir = Path.Combine(tempDir, projectName);
var buildOutpuDir = Path.Combine(tempDir, "output");
TestUtils.CopyFolder(projectSrcDir, projectDir);
var exitCode = DnuTestUtils.ExecDnu(runtimeHomeDir, "restore", projectDir);
Assert.Equal(0, exitCode);
exitCode = DnuTestUtils.ExecDnu(
runtimeHomeDir,
"pack",
$"{projectDir} --out {buildOutpuDir} --configuration {configuration}");
Assert.Equal(0, exitCode);
var assemblyPath = Path.Combine(buildOutpuDir, configuration, "dnx451", $"{projectName}.dll");
Assert.Equal(expectedServiceability, LockFileUtils.IsAssemblyServiceable(assemblyPath));
}
}
public void ResolveNewNamedResxResources()
{
var expected = new[]
{
"testproject.OwnResources.resources",
"testproject.subfolder.nestedresource.resources",
"thisIs.New.Resource.resources"
};
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var testProjectFolder = Path.Combine(rootDir, "misc", "ResourcesTestProjects", "testproject");
Project project = ProjectUtilities.GetProject(@"
{
""namedResource"": {
""thisIs.New.Resource"": ""../someresources/OtherResources.resx""
}
}",
"testproject",
Path.Combine(testProjectFolder, "project.json"));
var resolver = new ResxResourceProvider();
var embeddedResources = resolver.GetResources(project).Select(resource => resource.Name).ToArray();
Assert.Equal(expected, embeddedResources);
}
private bool WrapAssembly()
{
if (string.IsNullOrEmpty(Framework))
{
Reports.Error.WriteLine("Please specify framework when wrapping an assembly", Framework.Red().Bold());
return(false);
}
var frameworkName = VersionUtility.ParseFrameworkName(Framework);
if (VersionUtility.UnsupportedFrameworkName.Equals(frameworkName))
{
Reports.Error.WriteLine("The framework '{0}' is not supported", Framework.Red().Bold());
return(false);
}
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var wrapRoot = Path.Combine(rootDir, WrapRootName);
EmitAssemblyWrapper(wrapRoot, frameworkName, InputFilePath);
AddWrapFolderToGlobalJson(rootDir);
return(true);
}
private void WriteGlobalJson()
{
var rootDirectory = ProjectResolver.ResolveRootDirectory(_project.ProjectDirectory);
var rootObject = default(JObject);
if (GlobalSettings.HasGlobalFile(rootDirectory))
{
rootObject = JObject.Parse(File.ReadAllText(Path.Combine(
rootDirectory,
GlobalSettings.GlobalFileName)));
}
else
{
rootObject = new JObject();
}
var applicationRoot = Path.Combine(OutputPath, PublishRoot.AppRootName);
// All dependency projects go to approot/src folder
// so we remove all other useless entries that might bring in ambiguity
rootObject["projects"] = new JArray(SourceFolderName);
rootObject["packages"] = PathUtility.GetRelativePath(
PathUtility.EnsureTrailingForwardSlash(applicationRoot),
TargetPackagesPath, separator: '/');
File.WriteAllText(Path.Combine(applicationRoot, GlobalSettings.GlobalFileName),
rootObject.ToString());
}
public static int CreateDisposableTestProject(string runtimeHomeDir,
string targetDir,
string projectDir)
{
// Find the misc project to copy
var targetProjectDir = Path.Combine(targetDir, Path.GetFileName(projectDir));
CopyFolder(projectDir, targetProjectDir);
// Make sure package restore can be successful
var currentDnxSolutionRootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
File.Copy(Path.Combine(currentDnxSolutionRootDir, NuGet.Constants.SettingsFileName),
Path.Combine(targetProjectDir, NuGet.Constants.SettingsFileName));
// Use the newly built runtime to generate lock files for samples
string stdOut, stdErr;
return(DnuTestUtils.ExecDnu(
runtimeHomeDir,
subcommand: "restore",
arguments: targetProjectDir,
stdOut: out stdOut,
stdErr: out stdErr));
}
public static DisposableDir GetTempTestSolution(string name)
{
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var sourceSolutionPath = Path.Combine(rootDir, "misc", "KpmWrapTestSolutions", name);
var targetSolutionPath = CreateTempDir();
CopyFolder(sourceSolutionPath, targetSolutionPath);
return(targetSolutionPath);
}
public void WatchProject(string projectPath)
{
if (string.IsNullOrEmpty(projectPath))
{
return;
}
// If any watchers already handle this path then noop
if (!IsAlreadyWatched(projectPath))
{
// To reduce the number of watchers we have we add a watcher to the root
// of this project so that we'll be notified if anything we care
// about changes
var rootPath = ProjectResolver.ResolveRootDirectory(projectPath);
AddWatcher(rootPath);
}
}
public void ResolveEmbeddedResources()
{
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var testProjectFolder = Path.Combine(rootDir, "misc", "ResourcesTestProjects", "testproject");
Project project;
bool projectFound = Project.TryGetProject(testProjectFolder, out project);
Assert.True(projectFound);
var resolver = new EmbeddedResourceProvider();
var embeddedResource = resolver.GetResources(project);
Assert.Equal("testproject.owntext.txt", embeddedResource[0].Name);
Assert.Equal("testproject.subfolder.nestedtext.txt", embeddedResource[1].Name);
Assert.Equal("testproject.OtherText.txt", embeddedResource[2].Name);
}
public bool ExecuteCommand()
{
var sw = new Stopwatch();
sw.Start();
var restoreDirectory = RestoreDirectory ?? Directory.GetCurrentDirectory();
var projectJsonFiles = Directory.GetFiles(restoreDirectory, "project.json", SearchOption.AllDirectories);
var rootDirectory = ProjectResolver.ResolveRootDirectory(restoreDirectory);
ReadSettings(rootDirectory);
string packagesDirectory = PackageFolder;
if (string.IsNullOrEmpty(PackageFolder))
{
packagesDirectory = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
}
var packagesFolderFileSystem = CreateFileSystem(packagesDirectory);
var pathResolver = new DefaultPackagePathResolver(packagesFolderFileSystem, useSideBySidePaths: true);
var localRepository = new LocalPackageRepository(pathResolver, packagesFolderFileSystem);
int restoreCount = 0;
int successCount = 0;
foreach (var projectJsonPath in projectJsonFiles)
{
restoreCount += 1;
var success = RestoreForProject(localRepository, projectJsonPath, rootDirectory, packagesDirectory).Result;
if (success)
{
successCount += 1;
}
}
if (restoreCount > 1)
{
Reports.Information.WriteLine(string.Format("Total time {0}ms", sw.ElapsedMilliseconds));
}
return(restoreCount == successCount);
}
private static string ResolvePackagesDirectory(string projectDir)
{
var rootDir = ProjectResolver.ResolveRootDirectory(projectDir);
var settings = SettingsUtils.ReadSettings(
solutionDir: rootDir,
nugetConfigFile: null,
fileSystem: new PhysicalFileSystem(projectDir),
machineWideSettings: new CommandLineMachineWideSettings());
var packagesDir = settings.GetRepositoryPath();
// If 'repositoryPath' is not specified in NuGet.config, use {SolutionRoot}/packages as default
if (string.IsNullOrEmpty(packagesDir))
{
packagesDir = Path.Combine(rootDir, "packages");
}
return(Path.GetFullPath(packagesDir));
}
public void BuildPackageAndCheckServiceability(string projectName, bool expectedServiceability)
{
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var projectDir = Path.Combine(rootDir, "misc", "ServicingTestProjects", projectName);
const string configuration = "Debug";
using (var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor: "clr", os: "win", architecture: "x86"))
using (var tempDir = new DisposableDir())
{
var buildOutpuDir = Path.Combine(tempDir, "output");
DnuTestUtils.ExecDnu(
runtimeHomeDir,
"pack",
$"{projectDir} --out {buildOutpuDir} --configuration {configuration}");
var assemblyPath = Path.Combine(buildOutpuDir, configuration, "dnx451", $"{projectName}.dll");
Assert.Equal(expectedServiceability, LockFileUtils.IsAssemblyServiceable(assemblyPath));
}
}
public static DisposableDir PrepareTemporarySamplesFolder(string runtimeHomeDir)
{
var tempDir = new DisposableDir();
TestUtils.CopyFolder(TestUtils.GetSamplesFolder(), tempDir);
// Make sure sample projects depend on runtime components from newly built dnx
var currentDnxSolutionRootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var currentDnxSolutionSrcPath = Path.Combine(currentDnxSolutionRootDir, "src").Replace("\\", "\\\\");
var samplesGlobalJson = new JObject();
samplesGlobalJson["projects"] = new JArray(new[] { currentDnxSolutionSrcPath });
File.WriteAllText(Path.Combine(tempDir, GlobalSettings.GlobalFileName), samplesGlobalJson.ToString());
// Make sure package restore can be successful
const string nugetConfigName = "NuGet.Config";
File.Copy(Path.Combine(currentDnxSolutionRootDir, nugetConfigName), Path.Combine(tempDir, nugetConfigName));
// Use the newly built runtime to generate lock files for samples
string stdOut, stdErr;
int exitCode;
foreach (var projectDir in Directory.EnumerateDirectories(tempDir))
{
exitCode = DnuTestUtils.ExecDnu(
runtimeHomeDir,
subcommand: "restore",
arguments: projectDir,
stdOut: out stdOut,
stdErr: out stdErr);
if (exitCode != 0)
{
Console.WriteLine(stdOut);
Console.WriteLine(stdErr);
}
}
return(tempDir);
}
public void ResolveResxResources()
{
var expected = new[]
{
"testproject.OwnResources.resources",
"testproject.subfolder.nestedresource.resources",
"testproject.OtherResources.resources"
};
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var testProjectFolder = Path.Combine(rootDir, "misc", "ResourcesTestProjects", "testproject");
Project project;
bool projectFound = Project.TryGetProject(testProjectFolder, out project);
Assert.True(projectFound);
var resolver = new ResxResourceProvider();
var embeddedResources = resolver.GetResources(project).Select(resource => resource.Name).ToArray();
Assert.Equal(expected, embeddedResources);
}
public void ResolveRenamedResxResources()
{
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var testProjectFolder = Path.Combine(rootDir, "misc", "ResourcesTestProjects", "testproject");
Project project = ProjectUtilities.GetProject(@"
{
""namedResource"": {
""renamedResource"": ""subfolder/nestedresource.resx""
}
}",
"testproject",
Path.Combine(testProjectFolder, "project.json"));
var resolver = new ResxResourceProvider();
var embeddedResource = resolver.GetResources(project);
Assert.Equal("testproject.OwnResources.resources", embeddedResource[0].Name);
// This resource should get a new name instead of "testproject.subfolder.nestedresource.resources"
Assert.Equal("renamedResource.resources", embeddedResource[1].Name);
}
private void CopyRelativeSources(Runtime.Project project)
{
// We can reference source files outside of project root with "code" property in project.json,
// e.g. { "code" : "..\\ExternalProject\\**.cs" }
// So we find out external source files and copy them separately
var rootDirectory = ProjectResolver.ResolveRootDirectory(project.ProjectDirectory);
foreach (var sourceFile in project.Files.SourceFiles)
{
// This source file is in project root directory. So it was already copied.
if (PathUtility.IsChildOfDirectory(dir: project.ProjectDirectory, candidate: sourceFile))
{
continue;
}
// This source file is in solution root but out of project root,
// it is an external source file that we should copy here
if (PathUtility.IsChildOfDirectory(dir: rootDirectory, candidate: sourceFile))
{
// Keep the relativeness between external source files and project root,
var relativeSourcePath = PathUtility.GetRelativePath(project.ProjectFilePath, sourceFile);
var relativeParentDir = Path.GetDirectoryName(relativeSourcePath);
Directory.CreateDirectory(Path.Combine(TargetPath, relativeParentDir));
var targetFile = Path.Combine(TargetPath, relativeSourcePath);
if (!File.Exists(targetFile))
{
File.Copy(sourceFile, targetFile);
}
}
else
{
Console.WriteLine(
string.Format("TODO: Warning: the referenced source file '{0}' is not in solution root and it is not published to output.", sourceFile));
}
}
}
public static string GetXreTestAppPath(string name)
{
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
return(Path.Combine(rootDir, "misc", "XreTestApps", name));
}
private async Task <Tuple <string, string> > ResolvePackageIdAndVersion(string packageId, string packageVersion)
{
if (string.IsNullOrEmpty(packageId))
{
return(null);
}
// For nupkgs, get the id and version from the package
if (packageId.EndsWith(".nupkg", StringComparison.OrdinalIgnoreCase))
{
if (!File.Exists(packageId))
{
WriteError(string.Format("Could not find the file {0}.", packageId));
return(null);
}
var packagePath = Path.GetFullPath(packageId);
var packageDirectory = Path.GetDirectoryName(packagePath);
var zipPackage = new NuGet.ZipPackage(packagePath);
FeedOptions.FallbackSources.Add(packageDirectory);
return(new Tuple <string, string>(
zipPackage.Id,
zipPackage.Version.ToString()));
}
// If the version is missing, try to find the latest version
if (string.IsNullOrEmpty(packageVersion))
{
var rootDirectory = ProjectResolver.ResolveRootDirectory(_commandsRepository.Root.Root);
var config = NuGetConfig.ForSolution(rootDirectory, RestoreCommand.FileSystem);
var packageFeeds = new List <IPackageFeed>();
var effectiveSources = PackageSourceUtils.GetEffectivePackageSources(
config.Sources,
FeedOptions.Sources,
FeedOptions.FallbackSources);
foreach (var source in effectiveSources)
{
var feed = PackageSourceUtils.CreatePackageFeed(
source,
FeedOptions.NoCache,
FeedOptions.IgnoreFailedSources,
Reports);
if (feed != null)
{
packageFeeds.Add(feed);
}
}
var package = await PackageSourceUtils.FindLatestPackage(packageFeeds, packageId);
if (package == null)
{
Reports.Error.WriteLine("Unable to locate the package {0}".Red(), packageId);
return(null);
}
return(new Tuple <string, string>(
packageId,
package.Version.ToString()));
}
// Otherwise, just assume that what you got is correct
return(new Tuple <string, string>(packageId, packageVersion));
}
public async Task <bool> ExecuteCommand()
{
try
{
var sw = Stopwatch.StartNew();
// If the root argument is a project.json file
if (string.Equals(
NuGetProject.ProjectFileName,
Path.GetFileName(RestoreDirectory),
StringComparison.OrdinalIgnoreCase))
{
RestoreDirectory = Path.GetDirectoryName(Path.GetFullPath(RestoreDirectory));
}
if (!Directory.Exists(RestoreDirectory) && !string.IsNullOrEmpty(RestoreDirectory))
{
throw new InvalidOperationException("The given root is invalid.");
}
var restoreDirectory = RestoreDirectory ?? Directory.GetCurrentDirectory();
var rootDirectory = ProjectResolver.ResolveRootDirectory(restoreDirectory);
ReadSettings(rootDirectory);
string packagesDirectory = PackageFolder;
if (string.IsNullOrEmpty(PackageFolder))
{
packagesDirectory = ResolveRestoreTarget(rootDirectory);
}
int restoreCount = 0;
int successCount = 0;
var projectJsonFiles = Directory.GetFiles(restoreDirectory, "project.json", SearchOption.AllDirectories);
foreach (var projectJsonPath in projectJsonFiles)
{
restoreCount += 1;
var success = await RestoreForProject(projectJsonPath, rootDirectory, packagesDirectory);
if (success)
{
successCount += 1;
}
}
if (restoreCount > 1)
{
Logger.WriteInformation(string.Format("Total time {0}ms", sw.ElapsedMilliseconds));
}
return(restoreCount == successCount);
}
catch (Exception ex)
{
Logger.WriteInformation("----------");
Logger.WriteInformation(ex.ToString());
Logger.WriteInformation("----------");
Logger.WriteInformation("Restore failed");
Logger.WriteInformation(ex.Message);
return(false);
}
}
public static string GetSamplesFolder()
{
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
return(Path.Combine(rootDir, "samples"));
}
public async Task <bool> ExecuteCommand()
{
if (string.IsNullOrEmpty(_addCommand.Name))
{
Reports.Error.WriteLine("Name of dependency to install is required.".Red());
return(false);
}
SemanticVersion version = null;
if (!string.IsNullOrEmpty(_addCommand.Version))
{
version = SemanticVersion.Parse(_addCommand.Version);
}
// Create source provider from solution settings
_addCommand.ProjectDir = _addCommand.ProjectDir ?? Directory.GetCurrentDirectory();
var rootDir = ProjectResolver.ResolveRootDirectory(_addCommand.ProjectDir);
var fileSystem = new PhysicalFileSystem(Directory.GetCurrentDirectory());
var settings = SettingsUtils.ReadSettings(solutionDir: rootDir,
nugetConfigFile: null,
fileSystem: fileSystem,
machineWideSettings: new CommandLineMachineWideSettings());
var sourceProvider = PackageSourceBuilder.CreateSourceProvider(settings);
var effectiveSources = PackageSourceUtils.GetEffectivePackageSources(sourceProvider,
_restoreCommand.FeedOptions.Sources, _restoreCommand.FeedOptions.FallbackSources);
var packageFeeds = new List <IPackageFeed>();
foreach (var source in effectiveSources)
{
var feed = PackageSourceUtils.CreatePackageFeed(
source,
_restoreCommand.FeedOptions.NoCache,
_restoreCommand.FeedOptions.IgnoreFailedSources,
Reports);
if (feed != null)
{
packageFeeds.Add(feed);
}
}
PackageInfo result = null;
if (version == null)
{
result = await PackageSourceUtils.FindLatestPackage(packageFeeds, _addCommand.Name);
}
else
{
result = await PackageSourceUtils.FindBestMatchPackage(packageFeeds, _addCommand.Name, new SemanticVersionRange(version));
}
if (result == null)
{
Reports.Error.WriteLine("Unable to locate {0} >= {1}",
_addCommand.Name.Red().Bold(), _addCommand.Version);
return(false);
}
if (string.IsNullOrEmpty(_addCommand.Version))
{
_addCommand.Version = result.Version.ToString();
}
return(_addCommand.ExecuteCommand() && (await _restoreCommand.ExecuteCommand()));
}
public static string GetBuildArtifactsFolder()
{
var kRuntimeRoot = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
return(Path.Combine(kRuntimeRoot, "artifacts", "build"));
}
private void WriteGlobalJson()
{
var rootDirectory = ProjectResolver.ResolveRootDirectory(_project.ProjectDirectory);
var projectResolver = new ProjectResolver(_project.ProjectDirectory, rootDirectory);
var packagesDir = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
var nugetDependencyResolver = new NuGetDependencyResolver(packagesDir, new EmptyFrameworkResolver());
var pathResolver = new DefaultPackagePathResolver(PackagesPath);
var dependenciesObj = new JObject();
// Generate SHAs for all package dependencies
foreach (var deploymentPackage in Packages)
{
// Use the exactly same approach in PackPackage.Emit() to
// find the package actually in use
var package = nugetDependencyResolver.FindCandidate(
deploymentPackage.Library.Name,
deploymentPackage.Library.Version);
var shaFilePath = pathResolver.GetHashPath(package.Id, package.Version);
var sha = File.ReadAllText(shaFilePath);
var shaObj = new JObject();
shaObj.Add(new JProperty("version", package.Version.ToString()));
shaObj.Add(new JProperty("sha", sha));
dependenciesObj.Add(new JProperty(package.Id, shaObj));
}
// If "--no-source" is specified, project dependencies are packed to packages
// So we also generate SHAs for them in this case
foreach (var deploymentProject in Projects)
{
Runtime.Project project;
if (!projectResolver.TryResolveProject(deploymentProject.Name, out project))
{
throw new Exception("TODO: unable to resolve project named " + deploymentProject.Name);
}
var shaFilePath = pathResolver.GetHashPath(project.Name, project.Version);
if (!File.Exists(shaFilePath))
{
// This project is not packed to a package
continue;
}
var sha = File.ReadAllText(shaFilePath);
var shaObj = new JObject();
shaObj.Add(new JProperty("version", project.Version.ToString()));
shaObj.Add(new JProperty("sha", sha));
dependenciesObj.Add(new JProperty(project.Name, shaObj));
}
var rootObject = default(JObject);
if (GlobalSettings.HasGlobalFile(rootDirectory))
{
rootObject = JObject.Parse(File.ReadAllText(Path.Combine(
rootDirectory,
GlobalSettings.GlobalFileName)));
}
else
{
rootObject = new JObject();
}
var applicationRoot = Path.Combine(OutputPath, PackRoot.AppRootName);
rootObject["dependencies"] = dependenciesObj;
rootObject["packages"] = PathUtility.GetRelativePath(PathUtility.EnsureTrailingSlash(applicationRoot),
PackagesPath);
File.WriteAllText(Path.Combine(applicationRoot, GlobalSettings.GlobalFileName),
rootObject.ToString());
}
private async Task <bool> Execute(string restoreDirectory)
{
try
{
var sw = Stopwatch.StartNew();
var projectJsonFiles = new List <string>();
if (string.Equals(
Runtime.Project.ProjectFileName,
Path.GetFileName(restoreDirectory),
StringComparison.OrdinalIgnoreCase) && File.Exists(restoreDirectory))
{
// If the path is a project.json file we don't do recursive search in subfolders
projectJsonFiles.Add(restoreDirectory);
}
else if (Directory.Exists(restoreDirectory))
{
var projectJsonFile = Path.Combine(restoreDirectory, Runtime.Project.ProjectFileName);
if (File.Exists(projectJsonFile))
{
// If the path contains a project.json file we don't do recursive search in subfolders
projectJsonFiles.Add(projectJsonFile);
}
else
{
projectJsonFiles.AddRange(Directory.EnumerateFiles(
restoreDirectory,
Runtime.Project.ProjectFileName,
SearchOption.AllDirectories));
}
}
else
{
var errorMessage = $"The given root {restoreDirectory.Red().Bold()} is invalid.";
ErrorMessages.GetOrAdd(restoreDirectory, _ => new List <string>()).Add(errorMessage);
Reports.Error.WriteLine(errorMessage);
return(false);
}
var rootDirectory = ProjectResolver.ResolveRootDirectory(restoreDirectory);
ReadSettings(rootDirectory);
string packagesDirectory = FeedOptions.TargetPackagesFolder;
if (string.IsNullOrEmpty(packagesDirectory))
{
packagesDirectory = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
}
var packagesFolderFileSystem = CreateFileSystem(packagesDirectory);
var pathResolver = new DefaultPackagePathResolver(packagesFolderFileSystem, useSideBySidePaths: true);
int restoreCount = 0;
int successCount = 0;
Func <string, Task> restorePackage = async projectJsonPath =>
{
Interlocked.Increment(ref restoreCount);
var success = await RestoreForProject(projectJsonPath, rootDirectory, packagesDirectory);
if (success)
{
Interlocked.Increment(ref successCount);
}
};
if (!RestoringInParallel())
{
// Restoring in parallel on Mono throws native exception
foreach (var projectJsonFile in projectJsonFiles)
{
await restorePackage(projectJsonFile);
}
}
else
{
await ForEachAsync(
projectJsonFiles,
MaxDegreesOfConcurrency,
restorePackage);
}
if (restoreCount > 1)
{
Reports.Information.WriteLine(string.Format("Total time {0}ms", sw.ElapsedMilliseconds));
}
if (_installCount > 0)
{
InformationMessages.GetOrAdd("Installed:", _ => new List <string>()).Add($"{_installCount} package(s) to {packagesDirectory}");
_installCount = 0;
}
return(restoreCount == successCount);
}
catch (Exception ex)
{
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine(ex.ToString());
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine("Restore failed");
Reports.Information.WriteLine(ex.Message);
return(false);
}
}
public bool Execute()
{
var projectFile = ResolveProjectFile();
if (string.IsNullOrEmpty(projectFile))
{
return(false);
}
_solutionRoot = ProjectResolver.ResolveRootDirectory(projectFile);
var globalFile = GlobalSettings.GetGlobalFilePath(_solutionRoot);
if (!File.Exists(globalFile))
{
_reports.WriteError($"The '{GlobalSettings.GlobalFileName}' is missing from '{_solutionRoot}'.");
return(false);
}
var packagesFolder = ResolvePackagesFolder();
if (string.IsNullOrEmpty(packagesFolder))
{
return(false);
}
var packageVersion = ResolvePackageVersion(projectFile);
if (packageVersion == null)
{
return(false);
}
var packageResolver = new DefaultPackagePathResolver(packagesFolder);
var packageFolder = packageResolver.GetPackageDirectory(_packageId, packageVersion);
packageFolder = Path.Combine(packagesFolder, packageFolder);
var snapshotInfo = ReadRepositoryInfo(packageFolder);
if (snapshotInfo == null)
{
return(false);
}
string repoType;
if (!snapshotInfo.TryGetValue(Constants.RepoTypeKey, out repoType))
{
_reports.WriteError("Repository type information is missing from the repository information file.");
return(false);
}
var provider = SourceControlProviderFactory.ResolveProvider(repoType, _reports);
if (provider == null)
{
_reports.WriteError($"Unknown repository type '{repoType}'");
return(false);
}
if (!provider.IsInstalled)
{
_reports.WriteError($"The '{repoType}' client application is not installed.");
return(false);
}
var sourcesFolder = ResolveSourcesFolder();
var sourceFolderName = provider.CreateShortFolderName(snapshotInfo);
var sourceDestinationFullPath = Path.Combine(sourcesFolder, sourceFolderName);
if (!Directory.Exists(sourceDestinationFullPath))
{
_reports.WriteInformation($"Downloading sources in '{sourceDestinationFullPath}'...");
if (!provider.GetSources(sourceDestinationFullPath, snapshotInfo))
{
return(false);
}
}
else
{
_reports.WriteInformation($"Sources already found in '{sourceDestinationFullPath}'");
}
var srcFolder = provider.GetSourceFolderPath(snapshotInfo);
srcFolder = Path.Combine(sourceDestinationFullPath, srcFolder);
if (!Directory.Exists(srcFolder))
{
_reports.WriteError($"The source code folder '{srcFolder}' is missing.");
return(false);
}
_reports.Verbose.WriteLine($"Updating {GlobalSettings.GlobalFileName}...");
ModifyJson(globalFile, jObj =>
{
var projects = jObj["projects"] as JArray;
if (projects == null)
{
projects = new JArray();
projects.Add(srcFolder);
jObj.Add("projects", projects);
}
else
{
if (!projects.Any(t => t.ToString().Equals(srcFolder)))
{
projects.Add(srcFolder);
}
}
});
return(true);
}
public async Task <bool> ExecuteCommand()
{
try
{
var sw = Stopwatch.StartNew();
// If the root argument is a project.json file
if (string.Equals(
Runtime.Project.ProjectFileName,
Path.GetFileName(RestoreDirectory),
StringComparison.OrdinalIgnoreCase))
{
RestoreDirectory = Path.GetDirectoryName(Path.GetFullPath(RestoreDirectory));
}
// If the root argument is a global.json file
else if (string.Equals(
GlobalSettings.GlobalFileName,
Path.GetFileName(RestoreDirectory),
StringComparison.OrdinalIgnoreCase))
{
GlobalJsonFile = RestoreDirectory;
RestoreDirectory = Path.GetDirectoryName(Path.GetFullPath(RestoreDirectory));
}
else if (!Directory.Exists(RestoreDirectory) && !string.IsNullOrEmpty(RestoreDirectory))
{
throw new InvalidOperationException("The given root is invalid.");
}
var restoreDirectory = RestoreDirectory ?? Directory.GetCurrentDirectory();
var rootDirectory = ProjectResolver.ResolveRootDirectory(restoreDirectory);
ReadSettings(rootDirectory);
string packagesDirectory = PackageFolder;
if (string.IsNullOrEmpty(PackageFolder))
{
packagesDirectory = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
}
var packagesFolderFileSystem = CreateFileSystem(packagesDirectory);
var pathResolver = new DefaultPackagePathResolver(packagesFolderFileSystem, useSideBySidePaths: true);
int restoreCount = 0;
int successCount = 0;
if (string.IsNullOrEmpty(GlobalJsonFile))
{
var projectJsonFiles = Directory.GetFiles(restoreDirectory, "project.json", SearchOption.AllDirectories);
foreach (var projectJsonPath in projectJsonFiles)
{
restoreCount += 1;
var success = await RestoreForProject(projectJsonPath, rootDirectory, packagesDirectory);
if (success)
{
successCount += 1;
}
}
}
else
{
restoreCount = 1;
var success = await RestoreFromGlobalJson(rootDirectory, packagesDirectory);
if (success)
{
successCount = 1;
}
}
if (restoreCount > 1)
{
Reports.Information.WriteLine(string.Format("Total time {0}ms", sw.ElapsedMilliseconds));
}
return(restoreCount == successCount);
}
catch (Exception ex)
{
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine(ex.ToString());
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine("Restore failed");
Reports.Information.WriteLine(ex.Message);
return(false);
}
}
private void EmitProjectWrapper(XElement projectElement)
{
var projectFile = Path.GetFullPath(projectElement.Attribute("projectFile").Value);
// Name of the wrapper project is output assembly name, instead of .csproj file name
var outputAssemblyPath = GetOutputAssemblyPath(projectElement);
outputAssemblyPath = GetConfigAgnosticAssemblyPath(outputAssemblyPath);
var projectName = Path.GetFileNameWithoutExtension(outputAssemblyPath);
var projectDir = Path.GetDirectoryName(projectFile);
var rootDir = ProjectResolver.ResolveRootDirectory(projectDir);
var wrapRoot = Path.Combine(rootDir, WrapRootName);
string targetProjectJson;
if (InPlace)
{
targetProjectJson = Path.Combine(projectDir, Runtime.Project.ProjectFileName);
}
else
{
var projectResolver = new ProjectResolver(projectDir, rootDir);
targetProjectJson = LocateExistingProject(projectResolver, projectName);
if (string.IsNullOrEmpty(targetProjectJson))
{
AddWrapFolderToGlobalJson(rootDir);
targetProjectJson = Path.Combine(wrapRoot, projectName, Runtime.Project.ProjectFileName);
}
}
var targetFramework = GetTargetFramework(projectElement);
Reports.Information.WriteLine("Wrapping project '{0}' for '{1}'", projectName, targetFramework);
Reports.Information.WriteLine(" Source {0}", projectFile.Bold());
Reports.Information.WriteLine(" Target {0}", targetProjectJson.Bold());
var projectJson = LoadOrCreateProjectJson(targetProjectJson);
var relativeCsProjectPath = PathUtility.GetRelativePath(targetProjectJson, projectFile, PathSeparator);
AddWrappedProjectPath(projectJson, relativeCsProjectPath, targetFramework);
// Add 'assembly' and 'pdb' to 'bin' section of the target framework
var relativeAssemblyPath = PathUtility.GetRelativePath(targetProjectJson, outputAssemblyPath, PathSeparator);
var relativePdbPath = Path.ChangeExtension(relativeAssemblyPath, ".pdb");
Reports.Information.WriteLine(" Adding bin paths for '{0}'", targetFramework);
Reports.Information.WriteLine(" Assembly: {0}", relativeAssemblyPath.Bold());
Reports.Information.WriteLine(" Pdb: {0}", relativePdbPath.Bold());
AddFrameworkBinPaths(projectJson, targetFramework, relativeAssemblyPath, relativePdbPath);
var nugetPackages = ResolveNuGetPackages(projectDir);
var nugetPackagePaths = nugetPackages.Select(x => x.Path);
// Add nuget dependency to 'dependencies' section of the target framework
foreach (var package in nugetPackages)
{
Reports.Information.WriteLine(" Adding package dependency '{0}.{1}'",
package.Identity, package.Version);
AddNuGetDependency(projectJson, package, targetFramework);
}
// Add dependency projects to 'dependencies' section of the target framework
foreach (var itemElement in GetItemsByType(projectElement, type: "ProjectReference"))
{
var referenceProjectName = GetMetadataValue(itemElement, "Name");
var outputName = GetReferenceProjectOutputName(projectElement, referenceProjectName);
Reports.Information.WriteLine(" Adding project dependency '{0}.{1}'",
outputName, WrapperProjectVersion);
AddProjectDependency(projectJson, outputName, targetFramework);
}
// Create wrapper projects for assembly references
// and add wrapper projects as project references
foreach (var itemElement in GetItemsByType(projectElement, type: "ReferencePath"))
{
if (IsAssemblyFromProjectReference(itemElement) ||
IsFrameworkAssembly(itemElement) ||
IsAssemblyFromNuGetPackage(itemElement, nugetPackagePaths))
{
continue;
}
// This assembly becomes a project reference
var assemblyPath = itemElement.Attribute("evaluated").Value;
var assemblyProjectName = Path.GetFileNameWithoutExtension(assemblyPath);
EmitAssemblyWrapper(wrapRoot, targetFramework, assemblyPath, isSubProcedure: true);
Reports.Information.WriteLine(" Adding project dependency '{0}.{1}'",
assemblyProjectName, WrapperProjectVersion);
AddProjectDependency(projectJson, assemblyProjectName, targetFramework);
AddWrapFolderToGlobalJson(rootDir);
}
PathUtility.EnsureParentDirectory(targetProjectJson);
File.WriteAllText(targetProjectJson, projectJson.ToString());
AddToGlobalJsonSources(rootDir, Path.GetDirectoryName(targetProjectJson));
Reports.Information.WriteLine();
}
public async Task <bool> ExecuteCommand()
{
try
{
var sw = Stopwatch.StartNew();
// If the root argument is a project.json file
if (string.Equals(
Runtime.Project.ProjectFileName,
Path.GetFileName(RestoreDirectory),
StringComparison.OrdinalIgnoreCase))
{
RestoreDirectory = Path.GetDirectoryName(Path.GetFullPath(RestoreDirectory));
}
else if (!Directory.Exists(RestoreDirectory) && !string.IsNullOrEmpty(RestoreDirectory))
{
throw new InvalidOperationException("The given root is invalid.");
}
var restoreDirectory = RestoreDirectory ?? Directory.GetCurrentDirectory();
var rootDirectory = ProjectResolver.ResolveRootDirectory(restoreDirectory);
ReadSettings(rootDirectory);
string packagesDirectory = FeedOptions.TargetPackagesFolder;
if (string.IsNullOrEmpty(packagesDirectory))
{
packagesDirectory = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
}
var packagesFolderFileSystem = CreateFileSystem(packagesDirectory);
var pathResolver = new DefaultPackagePathResolver(packagesFolderFileSystem, useSideBySidePaths: true);
int restoreCount = 0;
int successCount = 0;
var projectJsonFiles = Directory.EnumerateFiles(
restoreDirectory,
Runtime.Project.ProjectFileName,
SearchOption.AllDirectories);
Func <string, Task> restorePackage = async projectJsonPath =>
{
Interlocked.Increment(ref restoreCount);
var success = await RestoreForProject(projectJsonPath, rootDirectory, packagesDirectory);
if (success)
{
Interlocked.Increment(ref successCount);
}
};
if (!Parallel || PlatformHelper.IsMono)
{
// Restoring in parallel on Mono throws native exception
foreach (var projectJsonFile in projectJsonFiles)
{
await restorePackage(projectJsonFile);
}
}
else
{
await ForEachAsync(
projectJsonFiles,
maxDegreesOfConcurrency : Environment.ProcessorCount,
body : restorePackage);
}
if (restoreCount > 1)
{
Reports.Information.WriteLine(string.Format("Total time {0}ms", sw.ElapsedMilliseconds));
}
foreach (var category in ErrorMessages)
{
Reports.Error.WriteLine("Errors in {0}".Red().Bold(), category.Key);
foreach (var message in category.Value)
{
Reports.Error.WriteLine(" {0}", message);
}
}
return(restoreCount == successCount);
}
catch (Exception ex)
{
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine(ex.ToString());
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine("Restore failed");
Reports.Information.WriteLine(ex.Message);
return(false);
}
}
private void WriteGlobalJson()
{
var rootDirectory = ProjectResolver.ResolveRootDirectory(_project.ProjectDirectory);
var projectResolver = new ProjectResolver(_project.ProjectDirectory, rootDirectory);
var packagesDir = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
var pathResolver = new DefaultPackagePathResolver(packagesDir);
var dependenciesObj = new JObject();
// Generate SHAs for all package dependencies
foreach (var deploymentPackage in Packages)
{
var library = deploymentPackage.Library;
var shaFilePath = pathResolver.GetHashPath(library.Name, library.Version);
if (!File.Exists(shaFilePath))
{
throw new FileNotFoundException("Expected SHA file doesn't exist", shaFilePath);
}
var sha = File.ReadAllText(shaFilePath);
var shaObj = new JObject();
shaObj["version"] = library.Version.ToString();
shaObj["sha"] = sha;
dependenciesObj[library.Name] = shaObj;
}
// If "--no-source" is specified, project dependencies are packed to packages
// So we also generate SHAs for them in this case
foreach (var deploymentProject in Projects)
{
Runtime.Project project;
if (!projectResolver.TryResolveProject(deploymentProject.Name, out project))
{
throw new Exception("TODO: unable to resolve project named " + deploymentProject.Name);
}
var shaFilePath = pathResolver.GetHashPath(project.Name, project.Version);
if (!File.Exists(shaFilePath))
{
// This project is not packed to a package
continue;
}
var sha = File.ReadAllText(shaFilePath);
var shaObj = new JObject();
shaObj.Add(new JProperty("version", project.Version.ToString()));
shaObj.Add(new JProperty("sha", sha));
dependenciesObj.Add(new JProperty(project.Name, shaObj));
}
var rootObject = default(JObject);
if (GlobalSettings.HasGlobalFile(rootDirectory))
{
rootObject = JObject.Parse(File.ReadAllText(Path.Combine(
rootDirectory,
GlobalSettings.GlobalFileName)));
}
else
{
rootObject = new JObject();
}
var applicationRoot = Path.Combine(OutputPath, BundleRoot.AppRootName);
rootObject["dependencies"] = dependenciesObj;
rootObject["packages"] = PathUtility.GetRelativePath(
PathUtility.EnsureTrailingForwardSlash(applicationRoot),
TargetPackagesPath, separator: '/');
File.WriteAllText(Path.Combine(applicationRoot, GlobalSettings.GlobalFileName),
rootObject.ToString());
}
public Task <int> Main(string[] args)
{
RuntimeOptions options;
string[] programArgs;
int exitCode;
bool shouldExit = ParseArgs(args, out options, out programArgs, out exitCode);
if (shouldExit)
{
return(Task.FromResult(exitCode));
}
IFileWatcher watcher;
if (options.WatchFiles)
{
watcher = new FileWatcher(ProjectResolver.ResolveRootDirectory(Path.GetFullPath(options.ApplicationBaseDirectory)));
}
else
{
watcher = NoopWatcher.Instance;
}
var host = new DefaultHost(options, _serviceProvider, _loadContextAccessor, watcher);
if (host.Project == null)
{
return(Task.FromResult(-1));
}
var lookupCommand = string.IsNullOrEmpty(options.ApplicationName) ? "run" : options.ApplicationName;
string replacementCommand;
if (host.Project.Commands.TryGetValue(lookupCommand, out replacementCommand))
{
// preserveSurroundingQuotes: false to imitate a shell. Shells remove quotation marks before calling
// Main methods. Here however we are invoking Main() without involving a shell.
var replacementArgs = CommandGrammar
.Process(replacementCommand, GetVariable, preserveSurroundingQuotes: false)
.ToArray();
options.ApplicationName = replacementArgs.First();
programArgs = replacementArgs.Skip(1).Concat(programArgs).ToArray();
}
if (string.IsNullOrEmpty(options.ApplicationName) ||
string.Equals(options.ApplicationName, "run", StringComparison.Ordinal))
{
options.ApplicationName = host.Project.EntryPoint ?? host.Project.Name;
}
IDisposable disposable = null;
try
{
disposable = host.AddLoaders(_container);
return(ExecuteMain(host, options.ApplicationName, programArgs)
.ContinueWith(async(t, state) =>
{
((IDisposable)state).Dispose();
return await t;
},
disposable).Unwrap());
}
catch
{
// If there's an error, dispose the host and throw
if (disposable != null)
{
disposable.Dispose();
}
throw;
}
}