public int Execute() { //add deps and runtime config to params var targetPath = Path.GetFullPath(AssemblyPath !); var targetDirectory = Path.GetDirectoryName(targetPath) !; var assemblyName = Path.GetFileNameWithoutExtension(targetPath); var depsFile = Path.Combine(targetDirectory, assemblyName + ".deps.json"); var runtimeConfig = Path.Combine(targetDirectory, assemblyName + ".runtimeconfig.json"); var args = new List <string> { "exec", "--depsfile", depsFile }; if (File.Exists(runtimeConfig)) { args.Add("--runtimeconfig"); args.Add(runtimeConfig); } //we want to run run PostgreSql.Exec var currentAssembly = Path.GetFullPath(Assembly.GetExecutingAssembly().Location) !; args.Add(currentAssembly); //pass the arguments args.AddRange(TemplateCreator.GetArgs(this)); return(Exe.Run("dotnet", args, targetDirectory)); }
public static bool RunTest(string toolchainName, Compiler compile, Exe runner, File source) { var destPath = tests_results.Combine(source); var sourcePath = tests.Combine(source); var expected = sourcePath.DropExtension().Combine(Ext(".o")); Console.Write($"\x1b[KRunning test {source} ({toolchainName}) "); destPath.DirName().Create(); UserErrorException exception = null; try { CompileToFile(compile, sourcePath, destPath); } catch (UserErrorException e) { exception = e; } if (exception != null) { Console.WriteLine(""); Console.WriteLine("\x1b[1;31mFail\x1b[m"); Console.WriteLine($"\x1b[1;33m{exception.Message}\x1b[m\n"); return(false); } else { var actualStr = runner.Run(destPath); var expectedStr = expected.Read(); if (actualStr != expectedStr) { Console.WriteLine("\x1b[1;31mFail\x1b[m"); Console.WriteLine($"\x1b[1;33m{source}: expected {expectedStr} but got {actualStr}.\x1b[m\n"); return(false); } else { Console.Write("\x1b[1;32mOK\x1b[m\n"); // \r at the end for quiet return(true); } } }
public void Build() { var args = new List <string> { "build" }; if (_file != null) { args.Add(_file); } // TODO: Only build for the first framework when unspecified if (_framework != null) { args.Add("--framework"); args.Add(_framework); } if (_configuration != null) { args.Add("--configuration"); args.Add(_configuration); } if (_runtime != null) { args.Add("--runtime"); args.Add(_runtime); } args.Add("/verbosity:quiet"); args.Add("/nologo"); var exitCode = Exe.Run("dotnet", args, interceptOutput: true); if (exitCode != 0) { throw new CommandException(Resources.BuildFailed); } }
protected override int Execute() { var thisPath = Path.GetFullPath(Path.GetDirectoryName(typeof(InvokeCommand).Assembly.Location)); var projectName = _projectOptions.ProjectName.Value(); var assemblyPath = _projectOptions.AssemblyPath.Value(); var targetDirectory = Path.GetDirectoryName(assemblyPath); string executable = null; var cleanupExecutable = false; try { string toolsDirectory; var args = new List <string>(); var targetFramework = new FrameworkName(_projectOptions.TargetFramework.Value()); switch (targetFramework.Identifier) { case ".NETFramework": cleanupExecutable = true; toolsDirectory = Path.Combine( thisPath, _projectOptions.Platform.Value() == "x86" ? "net461-x86" : "net461"); var executableSource = Path.Combine(toolsDirectory, InsideManName + ".exe"); executable = Path.Combine(targetDirectory, InsideManName + ".exe"); File.Copy(executableSource, executable, overwrite: true); var configPath = assemblyPath + ".config"; if (File.Exists(configPath)) { File.Copy(configPath, executable + ".config", overwrite: true); } break; case ".NETCoreApp": if (targetFramework.Version < new Version(2, 1)) { throw new CommandException(Resources.FormatOldNETCoreAppProject( projectName, targetFramework.Version)); } executable = DotNetMuxer.MuxerPathOrDefault(); toolsDirectory = Path.Combine(thisPath, "netcoreapp2.1"); args.Add("exec"); args.Add("--depsFile"); args.Add(Path.ChangeExtension(assemblyPath, ".deps.json")); var projectAssetsFile = _projectOptions.AssetsFile.Value(); if (!string.IsNullOrEmpty(projectAssetsFile) && File.Exists(projectAssetsFile)) { using var reader = new JsonTextReader(File.OpenText(projectAssetsFile)); var projectAssets = JToken.ReadFrom(reader); var packageFolders = projectAssets["packageFolders"] .Children <JProperty>() .Select(p => p.Name); foreach (var packageFolder in packageFolders) { args.Add("--additionalProbingPath"); args.Add(packageFolder.TrimEnd(Path.DirectorySeparatorChar)); } } var runtimeConfigPath = Path.ChangeExtension(assemblyPath, ".runtimeconfig.json"); if (File.Exists(runtimeConfigPath)) { args.Add("--runtimeConfig"); args.Add(runtimeConfigPath); } else { var runtimeFrameworkVersion = _projectOptions.RuntimeFrameworkVersion.Value(); if (!string.IsNullOrEmpty(runtimeFrameworkVersion)) { args.Add("--fx-version"); args.Add(runtimeFrameworkVersion); } } args.Add(Path.Combine(toolsDirectory, InsideManName + ".dll")); break; case ".NETStandard": throw new CommandException(Resources.FormatNETStandardProject(projectName)); default: throw new CommandException( Resources.FormatUnsupportedFramework(projectName, targetFramework.Identifier)); } args.AddRange(_args); args.Add("--assembly"); args.Add(assemblyPath); args.Add("--project"); args.Add(projectName); args.Add("--tools-directory"); args.Add(toolsDirectory); if (ReporterExtensions.PrefixOutput) { args.Add("--prefix-output"); } if (IsQuiet) { args.Add("--quiet"); } if (IsVerbose) { args.Add("--verbose"); } return(Exe.Run(executable, args, Reporter)); } finally { if (cleanupExecutable && !string.IsNullOrEmpty(executable)) { // Ignore errors about in-use files. Should still be marked for delete after process cleanup. try { File.Delete(executable); } catch (UnauthorizedAccessException) { } try { File.Delete(executable + ".config"); } catch (UnauthorizedAccessException) { } } } }
protected override int Execute(string[] _) { var commands = _args !.TakeWhile(a => a[0] != '-').ToList(); if (_help !.HasValue() || ShouldHelp(commands)) { return(ShowHelp(_help.HasValue(), commands)); } var(projectFile, startupProjectFile) = ResolveProjects( _project !.Value(), _startupProject !.Value()); Reporter.WriteVerbose(Resources.UsingProject(projectFile)); Reporter.WriteVerbose(Resources.UsingStartupProject(startupProjectFile)); var project = Project.FromFile(projectFile, _msbuildprojectextensionspath !.Value()); var startupProject = Project.FromFile( startupProjectFile, _msbuildprojectextensionspath.Value(), _framework !.Value(), _configuration !.Value(), _runtime !.Value()); if (!_noBuild !.HasValue()) { Reporter.WriteInformation(Resources.BuildStarted); startupProject.Build(); Reporter.WriteInformation(Resources.BuildSucceeded); } string executable; var args = new List <string>(); var toolsPath = Path.Combine( Path.GetDirectoryName(typeof(Program).Assembly.Location) !, "tools"); var targetDir = Path.GetFullPath(Path.Combine(startupProject.ProjectDir !, startupProject.OutputPath !)); var targetPath = Path.Combine(targetDir, project.TargetFileName !); var startupTargetPath = Path.Combine(targetDir, startupProject.TargetFileName !); var depsFile = Path.Combine( targetDir, startupProject.AssemblyName + ".deps.json"); var runtimeConfig = Path.Combine( targetDir, startupProject.AssemblyName + ".runtimeconfig.json"); var projectAssetsFile = startupProject.ProjectAssetsFile; var targetFramework = new FrameworkName(startupProject.TargetFrameworkMoniker !); if (targetFramework.Identifier == ".NETFramework") { executable = Path.Combine( toolsPath, "net461", startupProject.PlatformTarget == "x86" ? "win-x86" : "any", "ef.exe"); } else if (targetFramework.Identifier == ".NETCoreApp") { if (targetFramework.Version < new Version(2, 0)) { throw new CommandException( Resources.NETCoreApp1StartupProject(startupProject.ProjectName, targetFramework.Version)); } var targetPlatformIdentifier = startupProject.TargetPlatformIdentifier !; if (targetPlatformIdentifier.Length != 0 && !string.Equals(targetPlatformIdentifier, "Windows", StringComparison.OrdinalIgnoreCase)) { throw new CommandException(Resources.UnsupportedPlatform(startupProject.ProjectName, targetPlatformIdentifier)); } executable = "dotnet"; args.Add("exec"); args.Add("--depsfile"); args.Add(depsFile); if (!string.IsNullOrEmpty(projectAssetsFile)) { using var file = File.OpenRead(projectAssetsFile); using var reader = JsonDocument.Parse(file); var projectAssets = reader.RootElement; var packageFolders = projectAssets.GetProperty("packageFolders").EnumerateObject().Select(p => p.Name); foreach (var packageFolder in packageFolders) { args.Add("--additionalprobingpath"); args.Add(packageFolder.TrimEnd(Path.DirectorySeparatorChar)); } } if (File.Exists(runtimeConfig)) { args.Add("--runtimeconfig"); args.Add(runtimeConfig); } else if (startupProject.RuntimeFrameworkVersion !.Length != 0) { args.Add("--fx-version"); args.Add(startupProject.RuntimeFrameworkVersion); } args.Add(Path.Combine(toolsPath, "netcoreapp2.0", "any", "ef.dll")); } else if (targetFramework.Identifier == ".NETStandard") { throw new CommandException(Resources.NETStandardStartupProject(startupProject.ProjectName)); } else { throw new CommandException( Resources.UnsupportedFramework(startupProject.ProjectName, targetFramework.Identifier)); } args.AddRange(_args !); args.Add("--assembly"); args.Add(targetPath); args.Add("--project"); args.Add(projectFile); args.Add("--startup-assembly"); args.Add(startupTargetPath); args.Add("--startup-project"); args.Add(startupProjectFile); args.Add("--project-dir"); args.Add(project.ProjectDir !); args.Add("--root-namespace"); args.Add(project.RootNamespace !); args.Add("--language"); args.Add(project.Language !); args.Add("--framework"); args.Add(startupProject.TargetFramework !); if (_configuration.HasValue()) { args.Add("--configuration"); args.Add(_configuration.Value() !); } if (string.Equals(project.Nullable, "enable", StringComparison.OrdinalIgnoreCase) || string.Equals(project.Nullable, "annotations", StringComparison.OrdinalIgnoreCase)) { args.Add("--nullable"); } args.Add("--working-dir"); args.Add(Directory.GetCurrentDirectory()); if (Reporter.IsVerbose) { args.Add("--verbose"); } if (Reporter.NoColor) { args.Add("--no-color"); } if (Reporter.PrefixOutput) { args.Add("--prefix-output"); } if (_applicationArgs !.Any()) { args.Add("--"); args.AddRange(_applicationArgs !); } return(Exe.Run(executable, args, startupProject.ProjectDir)); }
public static Project FromFile( string file, string?buildExtensionsDir, string?framework = null, string?configuration = null, string?runtime = null) { Debug.Assert(!string.IsNullOrEmpty(file), "file is null or empty."); buildExtensionsDir ??= Path.Combine(Path.GetDirectoryName(file) !, "obj"); Directory.CreateDirectory(buildExtensionsDir); var efTargetsPath = Path.Combine( buildExtensionsDir, Path.GetFileName(file) + ".EntityFrameworkCore.targets"); using (var input = typeof(Resources).Assembly.GetManifestResourceStream( "Microsoft.EntityFrameworkCore.Tools.Resources.EntityFrameworkCore.targets") !) using (var output = File.OpenWrite(efTargetsPath)) { // NB: Copy always in case it changes Reporter.WriteVerbose(Resources.WritingFile(efTargetsPath)); input.CopyTo(output); } IDictionary <string, string> metadata; var metadataFile = Path.GetTempFileName(); try { var propertyArg = "/property:EFProjectMetadataFile=" + metadataFile; if (framework != null) { propertyArg += ";TargetFramework=" + framework; } if (configuration != null) { propertyArg += ";Configuration=" + configuration; } if (runtime != null) { propertyArg += ";RuntimeIdentifier=" + runtime; } var args = new List <string> { "msbuild", "/target:GetEFProjectMetadata", propertyArg, "/verbosity:quiet", "/nologo" }; args.Add(file); var exitCode = Exe.Run("dotnet", args); if (exitCode != 0) { throw new CommandException(Resources.GetMetadataFailed); } metadata = File.ReadLines(metadataFile).Select(l => l.Split(new[] { ':' }, 2)) .ToDictionary(s => s[0], s => s[1].TrimStart()); } finally { File.Delete(metadataFile); } var platformTarget = metadata["PlatformTarget"]; if (platformTarget.Length == 0) { platformTarget = metadata["Platform"]; } return(new Project(file, framework, configuration, runtime) { AssemblyName = metadata["AssemblyName"], Language = metadata["Language"], OutputPath = metadata["OutputPath"], PlatformTarget = platformTarget, ProjectAssetsFile = metadata["ProjectAssetsFile"], ProjectDir = metadata["ProjectDir"], RootNamespace = metadata["RootNamespace"], RuntimeFrameworkVersion = metadata["RuntimeFrameworkVersion"], TargetFileName = metadata["TargetFileName"], TargetFrameworkMoniker = metadata["TargetFrameworkMoniker"], Nullable = metadata["Nullable"], TargetFramework = metadata["TargetFramework"], TargetPlatformIdentifier = metadata["TargetPlatformIdentifier"] }); }
protected override int Execute() { var projectFile = FindProjects( _project.Value(), Resources.NoProject, Resources.MultipleProjects); Reporter.WriteVerbose(Resources.FormatUsingProject(projectFile)); var project = Project.FromFile( projectFile, _projectExtensionsPath.Value(), _targetFramework.Value(), _configuration.Value(), _runtime.Value()); if (!File.Exists(project.TargetPath)) { throw new CommandException(Resources.MustBuild); } var thisPath = Path.GetFullPath(Path.GetDirectoryName(typeof(InvokeCommand).Assembly.Location)); string executable = null; var cleanupExecutable = false; try { string toolsDirectory; var args = new List <string>(); var targetFramework = new FrameworkName(project.TargetFrameworkMoniker); switch (targetFramework.Identifier) { case ".NETFramework": cleanupExecutable = true; executable = Path.Combine(project.OutputPath, InsideManName + ".exe"); toolsDirectory = Path.Combine( thisPath, project.PlatformTarget == "x86" ? "net461-x86" : "net461"); var executableSource = Path.Combine(toolsDirectory, InsideManName + ".exe"); File.Copy(executableSource, executable, overwrite: true); if (!string.IsNullOrEmpty(project.ConfigPath)) { File.Copy(project.ConfigPath, executable + ".config", overwrite: true); } break; case ".NETCoreApp": executable = "dotnet"; toolsDirectory = Path.Combine(thisPath, "netcoreapp2.0"); if (targetFramework.Version < new Version(2, 0)) { throw new CommandException( Resources.FormatNETCoreApp1Project(project.ProjectName, targetFramework.Version)); } args.Add("exec"); args.Add("--depsFile"); args.Add(project.ProjectDepsFilePath); if (!string.IsNullOrEmpty(project.ProjectAssetsFile)) { using (var reader = new JsonTextReader(File.OpenText(project.ProjectAssetsFile))) { var projectAssets = JToken.ReadFrom(reader); var packageFolders = projectAssets["packageFolders"] .Children <JProperty>() .Select(p => p.Name); foreach (var packageFolder in packageFolders) { args.Add("--additionalProbingPath"); args.Add(packageFolder.TrimEnd(Path.DirectorySeparatorChar)); } } } if (File.Exists(project.ProjectRuntimeConfigFilePath)) { args.Add("--runtimeConfig"); args.Add(project.ProjectRuntimeConfigFilePath); } else if (!string.IsNullOrEmpty(project.RuntimeFrameworkVersion)) { args.Add("--fx-version"); args.Add(project.RuntimeFrameworkVersion); } args.Add(Path.Combine(toolsDirectory, InsideManName + ".dll")); break; case ".NETStandard": throw new CommandException(Resources.FormatNETStandardProject(project.ProjectName)); default: throw new CommandException( Resources.FormatUnsupportedFramework(project.ProjectName, targetFramework.Identifier)); } args.AddRange(_args); args.Add("--assembly"); args.Add(project.TargetPath); args.Add("--tools-directory"); args.Add(toolsDirectory); if (!(args.Contains("--method") || string.IsNullOrEmpty(project.DefaultMethod))) { args.Add("--method"); args.Add(project.DefaultMethod); } if (!(args.Contains("--service") || string.IsNullOrEmpty(project.DefaultService))) { args.Add("--service"); args.Add(project.DefaultService); } if (_output.HasValue()) { args.Add("--output"); args.Add(Path.GetFullPath(_output.Value())); } if (Reporter.IsVerbose) { args.Add("--verbose"); } if (Reporter.NoColor) { args.Add("--no-color"); } if (Reporter.PrefixOutput) { args.Add("--prefix-output"); } return(Exe.Run(executable, args, project.ProjectDirectory)); } finally { if (cleanupExecutable && !string.IsNullOrEmpty(executable)) { // Ignore errors about in-use files. Should still be marked for delete after process cleanup. try { File.Delete(executable); } catch (UnauthorizedAccessException) { } try { File.Delete(executable + ".config"); } catch (UnauthorizedAccessException) { } } } }