private static int Main(string[] args)
{
if (Console.IsOutputRedirected)
{
Console.OutputEncoding = Encoding.UTF8;
}
var app = new CommandLineApplication {
Name = "ef"
};
new RootCommand().Configure(app);
try
{
return(app.Execute(args));
}
catch (Exception ex)
{
var wrappedException = ex as WrappedException;
if (ex is CommandException ||
ex is CommandParsingException ||
(wrappedException?.Type == "Microsoft.EntityFrameworkCore.Design.OperationException"))
{
Reporter.WriteVerbose(ex.ToString());
}
else
{
Reporter.WriteInformation(ex.ToString());
}
Reporter.WriteError(ex.Message);
return(1);
}
}
public static int Run(string executable, IReadOnlyList <string> args, string workingDirectory = null)
{
var arguments = ToArguments(args);
Reporter.WriteVerbose(executable + " " + arguments);
var startInfo = new ProcessStartInfo
{
FileName = executable,
Arguments = arguments,
UseShellExecute = false
};
if (workingDirectory != null)
{
startInfo.WorkingDirectory = workingDirectory;
}
var build = Process.Start(startInfo);
build.WaitForExit();
return(build.ExitCode);
}
public AppDomainOperationExecutor(
string assembly,
string?startupAssembly,
string?projectDir,
string?dataDirectory,
string?rootNamespace,
string?language,
bool nullable,
string[] remainingArguments)
: base(assembly, startupAssembly, projectDir, rootNamespace, language, nullable, remainingArguments)
{
var info = new AppDomainSetup {
ApplicationBase = AppBasePath
};
var configurationFile = (startupAssembly ?? assembly) + ".config";
if (File.Exists(configurationFile))
{
Reporter.WriteVerbose(Resources.UsingConfigurationFile(configurationFile));
info.ConfigurationFile = configurationFile;
}
_domain = AppDomain.CreateDomain("EntityFrameworkCore.DesignDomain", null, info);
if (dataDirectory != null)
{
Reporter.WriteVerbose(Resources.UsingDataDir(dataDirectory));
_domain.SetData("DataDirectory", dataDirectory);
}
var reportHandler = new OperationReportHandler(
Reporter.WriteError,
Reporter.WriteWarning,
Reporter.WriteInformation,
Reporter.WriteVerbose);
_executor = _domain.CreateInstanceAndUnwrap(
DesignAssemblyName,
ExecutorTypeName,
false,
BindingFlags.Default,
null,
new object[]
{
reportHandler,
new Hashtable
{
{ "targetName", AssemblyFileName },
{ "startupTargetName", StartupAssemblyFileName },
{ "projectDir", ProjectDirectory },
{ "rootNamespace", RootNamespace },
{ "language", Language },
{ "nullable", Nullable },
{ "toolsVersion", ProductInfo.GetVersion() },
{ "remainingArguments", RemainingArguments }
}
},
null,
null);
}
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.");
if (buildExtensionsDir == null)
{
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).GetTypeInfo().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"
};
if (file != null)
{
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"],
OutputPath = metadata["OutputPath"],
PlatformTarget = platformTarget,
ProjectAssetsFile = metadata["ProjectAssetsFile"],
ProjectDir = metadata["ProjectDir"],
RootNamespace = metadata["RootNamespace"],
RuntimeFrameworkVersion = metadata["RuntimeFrameworkVersion"],
TargetFileName = metadata["TargetFileName"],
TargetFrameworkMoniker = metadata["TargetFrameworkMoniker"]
});
}
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));
}
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("--startup-assembly");
args.Add(startupTargetPath);
args.Add("--project-dir");
args.Add(project.ProjectDir);
args.Add("--language");
args.Add(project.Language);
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 (project.RootNamespace.Length != 0)
{
args.Add("--root-namespace");
args.Add(project.RootNamespace);
}
if (_applicationArgs.Any())
{
args.Add("--");
args.AddRange(_applicationArgs);
}
return(Exe.Run(executable, args, startupProject.ProjectDir));
}
public static CommandLineOptions Parse(params string[] args)
{
var options = new CommandLineOptions();
var app = new CommandLineApplication
{
#if NET451
Name = "ef",
#else
Name = "ef",
#endif
FullName = "Entity Framework Core Command Line Tools"
};
app.HelpOption();
app.VersionOption(Program.GetVersion);
var verbose = app.Option("--verbose", "Show verbose output", inherited: true);
var noColor = app.Option("--no-color", "Do not use color in console output");
// so "WriteLogo" gets the right option set before parsing the remainder of the args
if (args.Any(a => a.Equals("--no-color")))
{
Reporter.Use(new ConsoleReporter());
}
var prefixOutput = app.Option("--prefix-output", "(internal flag) prefix output");
prefixOutput.ShowInHelpText = false;
if (args.Any(a => a.Equals("--prefix-output")))
{
Reporter.Use(new PrefixConsoleReporter());
}
// required
var assembly = app.Option("--assembly <assembly>",
"The assembly file to load.", inherited: true);
#if NET451
var appConfig = app.Option("--config <configfile>",
"The application config file", inherited: true);
var noAppDomain = app.Option("--no-appdomain",
"Do not use app domains to execute the command");
#endif
// common options
var startupAssembly = app.Option("--startup-assembly <assembly>",
"The assembly file containing the startup class.", inherited: true);
var dataDirectory = app.Option("--data-dir <dir>",
"The folder used as the data directory (defaults to current working directory).", inherited: true);
var projectDirectory = app.Option("--project-dir <dir>",
"The folder used as the project directory (defaults to current working directory).", inherited: true);
var contentRootPath = app.Option("--content-root-path <dir>",
"The folder used as the content root path for the application (defaults to application base directory).", inherited: true);
var rootNamespace = app.Option("--root-namespace <namespace>",
"The root namespace of the target project (defaults to the project assembly name).", inherited: true);
var environment = app.Option(
"-e|--environment <environment>",
"The environment to use. If omitted, \"Development\" is used.", inherited: true);
EfCommand.Configure(app, options);
var result = app.Execute(args);
if (result != 0)
{
return(null);
}
options.IsHelp = app.IsShowingInformation;
options.Verbose = verbose.HasValue();
options.NoColor = noColor.HasValue();
options.Assembly = assembly.Value();
options.StartupAssembly = startupAssembly.Value();
options.DataDirectory = dataDirectory.Value();
options.ProjectDirectory = projectDirectory.Value();
options.ContentRootPath = contentRootPath.Value();
options.RootNamespace = rootNamespace.Value();
options.EnvironmentName = environment.Value();
#if NET451
options.AppConfigFile = appConfig.Value();
options.NoAppDomain = noAppDomain.HasValue();
#endif
return(options);
}
protected override int Execute()
{
var commands = _args.TakeWhile(a => a[0] != '-').ToList();
if (_help.HasValue() || ShouldHelp(commands))
{
return(ShowHelp(_help.HasValue(), commands));
}
var projectFile = FindProjects(
_project.Value(),
Resources.NoProject,
Resources.MultipleProjects);
Reporter.WriteVerbose(Resources.UsingProject(projectFile));
var starupProjectFile = FindProjects(
_startupProject.Value(),
Resources.NoStartupProject,
Resources.MultipleStartupProjects);
Reporter.WriteVerbose(Resources.UsingStartupProject(starupProjectFile));
var project = Project.FromFile(projectFile, _msbuildprojectextensionspath.Value());
var startupProject = Project.FromFile(
starupProjectFile,
_msbuildprojectextensionspath.Value(),
_framework.Value(),
_configuration.Value(),
_runtime.Value());
if (!_noBuild.HasValue())
{
startupProject.Build();
}
string executable;
var args = new List <string>();
var toolsPath = Path.GetFullPath(
Path.Combine(
Path.GetDirectoryName(typeof(Program).GetTypeInfo().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"
? "ef.x86.exe"
: "ef.exe");
}
else if (targetFramework.Identifier == ".NETCoreApp")
{
executable = "dotnet";
args.Add("exec");
args.Add("--depsfile");
args.Add(depsFile);
if (!string.IsNullOrEmpty(projectAssetsFile))
{
using (var reader = new JsonTextReader(File.OpenText(projectAssetsFile)))
{
var projectAssets = JObject.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(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", "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("--startup-assembly");
args.Add(startupTargetPath);
args.Add("--project-dir");
args.Add(project.ProjectDir);
if (Reporter.IsVerbose)
{
args.Add("--verbose");
}
if (Reporter.NoColor)
{
args.Add("--no-color");
}
if (Reporter.PrefixOutput)
{
args.Add("--prefix-output");
}
if (project.RootNamespace.Length != 0)
{
args.Add("--root-namespace");
args.Add(project.RootNamespace);
}
return(Exe.Run(executable, args, startupProject.ProjectDir));
}
