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