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)
{
}
}
}
}
