public OperationExecutor(
[NotNull] CommonOptions options,
[CanBeNull] string environment)
{
var projectFile = Path.Combine(Directory.GetCurrentDirectory(), Project.FileName);
var project = ProjectReader.GetProject(projectFile);
var projectConfiguration = options.Configuration ?? Constants.DefaultConfiguration;
var projectFramework = options.Framework;
var projectContext = ProjectContext.Create(project.ProjectFilePath,
projectFramework,
RuntimeEnvironmentRidExtensions.GetAllCandidateRuntimeIdentifiers());
var runtimeOutputPath = projectContext.GetOutputPaths(projectConfiguration)?.RuntimeOutputPath;
if (!string.IsNullOrEmpty(runtimeOutputPath))
{
Reporter.Verbose.WriteLine(
ToolsCliStrings.LogDataDirectory(runtimeOutputPath));
Environment.SetEnvironmentVariable(DataDirEnvName, runtimeOutputPath);
#if NET451
AppDomain.CurrentDomain.SetData("DataDirectory", runtimeOutputPath);
#endif
}
var assemblyName = project.GetCompilerOptions(projectFramework, projectConfiguration).OutputName;
var projectDir = project.ProjectDirectory;
var rootNamespace = project.Name;
var assemblyLoader = new AssemblyLoader(Assembly.Load);
var projectAssembly = assemblyLoader.Load(assemblyName);
_contextOperations = new LazyRef <DbContextOperations>(
() => new DbContextOperations(
new LoggerProvider(name => new ConsoleCommandLogger(name)),
projectAssembly,
projectAssembly,
environment,
projectDir));
_databaseOperations = new LazyRef <DatabaseOperations>(
() => new DatabaseOperations(
new LoggerProvider(name => new ConsoleCommandLogger(name)),
assemblyLoader,
projectAssembly,
environment,
projectDir,
projectDir,
rootNamespace));
_migrationsOperations = new LazyRef <MigrationsOperations>(
() => new MigrationsOperations(
new LoggerProvider(name => new ConsoleCommandLogger(name)),
projectAssembly,
assemblyLoader,
projectAssembly,
environment,
projectDir,
projectDir,
rootNamespace));
}
private void OnProjectChanged(object sender, FileSystemEventArgs e)
{
var project = ProjectReader.GetProject(this.projectFilePath);
var json = JsonConvert.SerializeObject(project, this.jsonSerializerSettings);
File.WriteAllText(this.projectJsonFilePath, json);
}
public BuildCommand(
string projectPath,
string output = "",
string tempOutput = "",
string configuration = "",
bool noHost = false,
bool native = false,
string architecture = "",
string ilcArgs = "",
string ilcPath = "",
string appDepSDKPath = "",
bool nativeCppMode = false,
string cppCompilerFlags = ""
)
: base("dotnet")
{
_projectPath = projectPath;
_project = ProjectReader.GetProject(projectPath);
_outputDirectory = output;
_tempOutputDirectory = tempOutput;
_configuration = configuration;
_noHost = noHost;
_native = native;
_architecture = architecture;
_ilcArgs = ilcArgs;
_ilcPath = ilcPath;
_appDepSDKPath = appDepSDKPath;
_nativeCppMode = nativeCppMode;
_cppCompilerFlags = cppCompilerFlags;
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
var app = new CommandLineApplication(false)
{
Name = "dotnet restore",
FullName = ".NET project dependency restorer",
Description = "Restores dependencies listed in project.json"
};
// Parse --quiet, because we have to handle that specially since NuGet3 has a different
// "--verbosity" switch that goes BEFORE the command
var quiet = args.Any(s => s.Equals("--quiet", StringComparison.OrdinalIgnoreCase));
args = args.Where(s => !s.Equals("--quiet", StringComparison.OrdinalIgnoreCase)).ToArray();
// Until NuGet/Home#1941 is fixed, if no RIDs are specified, add our own.
if (!args.Any(s => s.Equals("--runtime", StringComparison.OrdinalIgnoreCase)))
{
args = Enumerable.Concat(
args,
PlatformServices.Default.Runtime.GetOverrideRestoreRuntimeIdentifiers().SelectMany(r => new [] { "--runtime", r })
).ToArray();
}
app.OnExecute(() =>
{
try
{
var projectRestoreResult = NuGet3.Restore(args, quiet);
var restoreTasks = GetRestoreTasks(args);
foreach (var restoreTask in restoreTasks)
{
var project = ProjectReader.GetProject(restoreTask.ProjectPath);
RestoreTools(project, restoreTask, quiet);
}
return(projectRestoreResult);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
return(-1);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(-2);
}
});
return(app.Execute(args));
}
private void OnProjectJsonChanged(object sender, FileSystemEventArgs e)
{
var project = ProjectReader.GetProject(this.projectFilePath);
var json = File.ReadAllText(this.projectJsonFilePath);
var newProject = JsonConvert.DeserializeObject <Project>(json);
Mapper.Map(newProject, project);
}
private static ProjectContext GetProjectContext(string applicationBasePath, string framework)
{
var project = ProjectReader.GetProject(Path.Combine(applicationBasePath, "project.json"));
return(new ProjectContextBuilder()
.WithProject(project)
.WithTargetFramework(framework)
.Build());
}
public PublishCommand(string projectPath, string framework = "", string runtime = "", string output = "", string config = "")
: base("dotnet")
{
_path = projectPath;
_project = ProjectReader.GetProject(projectPath);
_framework = framework;
_runtime = runtime;
_output = output;
_config = config;
}
protected override int OnExecute()
{
var projectFile = ProjectReader.GetProject(ProjectArgument.Value);
var targetFrameworks = projectFile
.GetTargetFrameworks()
.Select(frameworkInformation => frameworkInformation.FrameworkName);
NuGetFramework framework;
if (!TryResolveFramework(targetFrameworks, out framework))
{
// Could not resolve framework for dispatch. Error was reported, exit early.
return(0);
}
var dispatchArgs = new List <string>
{
CommandName,
AssemblyNamesArgument.Value,
};
if (ProtocolOption.HasValue())
{
dispatchArgs.Add("--protocol");
dispatchArgs.Add(ProtocolOption.Value());
}
var dispatchCommand = DotnetToolDispatcher.CreateDispatchCommand(
dispatchArgs,
framework,
ConfigurationOption.Value(),
outputPath: null,
buildBasePath: BuildBasePathOption.Value(),
projectDirectory: projectFile.ProjectDirectory);
using (var errorWriter = new StringWriter())
{
var commandExitCode = dispatchCommand
.ForwardStdErr(errorWriter)
.ForwardStdOut()
.Execute()
.ExitCode;
if (commandExitCode != 0)
{
ReportError(
string.Format(
CultureInfo.CurrentCulture,
Resources.FailedToExecuteRazorTooling,
errorWriter.ToString()));
}
return(0);
}
}
public PublishCommand(string projectPath, string framework = "", string runtime = "", string output = "", string config = "", bool forcePortable = false, bool noBuild = false)
: base("dotnet")
{
_path = projectPath;
_project = ProjectReader.GetProject(projectPath);
_framework = framework;
_runtime = runtime;
_output = output;
_config = config;
_noBuild = noBuild;
}
static void Main(string[] args)
{
var connectCentre = new ConnectionCentre();
connectCentre.Connect("http://test0000003.atlassian.net", "admin", "11111111");
var projectReader = new ProjectReader();
var project = projectReader.GetProject("PROJ");
Console.WriteLine(project.Name);
Console.WriteLine(project.Lead.Name);
Console.ReadKey();
}
private void HoistFrameworkAssembliesForDesktopFrameworks(
ProjectDependency projectDependency,
ProjectRootElement outputMSBuildProject)
{
var targetFrameworks = ProjectReader
.GetProject(projectDependency.ProjectFilePath)
.GetTargetFrameworks().Where(p => !p.FrameworkName.IsPackageBased);
foreach (var targetFramework in targetFrameworks)
{
HoistFrameworkAssemblies(targetFramework, outputMSBuildProject);
}
}
public static int Run(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
var app = new CommandLineApplication(false)
{
Name = "dotnet restore",
FullName = ".NET project dependency restorer",
Description = "Restores dependencies listed in project.json"
};
// Parse --quiet, because we have to handle that specially since NuGet3 has a different
// "--verbosity" switch that goes BEFORE the command
var quiet = args.Any(s => s.Equals("--quiet", StringComparison.OrdinalIgnoreCase));
args = args.Where(s => !s.Equals("--quiet", StringComparison.OrdinalIgnoreCase)).ToArray();
app.OnExecute(() =>
{
try
{
var projectRestoreResult = NuGet3.Restore(args, quiet);
var restoreTasks = GetRestoreTasks(args);
foreach (var restoreTask in restoreTasks)
{
var project = ProjectReader.GetProject(restoreTask.ProjectPath);
RestoreTools(project, restoreTask, quiet);
}
return(projectRestoreResult);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
return(-1);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(-2);
}
});
return(app.Execute(args));
}
public BuildCommand(
string projectPath,
string output = "",
string buildBasePath = "",
string configuration = "",
string framework = "",
string runtime = "",
string versionSuffix = "",
bool noHost = false,
bool native = false,
string architecture = "",
string ilcArgs = "",
string ilcPath = "",
string appDepSDKPath = "",
bool nativeCppMode = false,
string cppCompilerFlags = "",
bool buildProfile = true,
bool noIncremental = false,
bool noDependencies = false,
bool verbose = true,
bool skipLoadProject = false)
: base("dotnet")
{
_projectPath = projectPath;
if (!skipLoadProject)
{
_project = ProjectReader.GetProject(projectPath);
}
_outputDirectory = output;
_buildBasePathDirectory = buildBasePath;
_configuration = configuration;
_versionSuffix = versionSuffix;
_framework = framework;
_runtime = runtime;
_noHost = noHost;
_native = native;
_architecture = architecture;
_ilcArgs = ilcArgs;
_ilcPath = ilcPath;
_appDepSDKPath = appDepSDKPath;
_nativeCppMode = nativeCppMode;
_cppCompilerFlags = cppCompilerFlags;
_buildProfile = buildProfile;
_noIncremental = noIncremental;
_noDependencies = noDependencies;
_verbose = verbose;
}
private ProjectContext GetCompatibleStartupProjectContext(string startupProjectPath, NuGetFramework projectFramework)
{
var startupProject = ProjectReader.GetProject(startupProjectPath);
var frameworks = startupProject.GetTargetFrameworks()
.Select(f => f.FrameworkName);
var startupFramework = frameworks.FirstOrDefault(f => f.Equals(projectFramework));
if (startupFramework == null)
{
if (projectFramework.IsDesktop())
{
startupFramework = frameworks.FirstOrDefault(f => f.IsDesktop())
?? NuGetFrameworkUtility.GetNearest(
frameworks,
FrameworkConstants.CommonFrameworks.NetStandard15,
f => f);
}
else
{
startupFramework = NuGetFrameworkUtility.GetNearest(
frameworks,
FrameworkConstants.CommonFrameworks.NetCoreApp10,
f => f)
// TODO remove fallback to dnxcore50
?? NuGetFrameworkUtility.GetNearest(
frameworks,
FrameworkConstants.CommonFrameworks.DnxCore50,
f => f);
}
}
if (startupFramework == null)
{
throw new OperationException(
ToolsCliStrings.IncompatibleStartupProject(startupProject.Name, projectFramework.GetShortFolderName()));
}
Reporter.Verbose.WriteLine(
ToolsCliStrings.LogUsingFramework(startupFramework.GetShortFolderName(), startupProject.Name).Bold().Black());
return(new ProjectContextBuilder()
.WithProject(startupProject)
.WithTargetFramework(startupFramework)
.WithRuntimeIdentifiers(PlatformServices.Default.Runtime.GetAllCandidateRuntimeIdentifiers())
.Build());
}
public PublishCommand(string projectPath,
string framework = "",
string runtime = "",
string output = "",
string config = "",
bool noBuild = false,
string buildBasePath = "")
: base("dotnet")
{
_path = projectPath;
_project = ProjectReader.GetProject(projectPath);
_framework = framework;
_runtime = runtime;
_output = output;
_config = config;
_noBuild = noBuild;
_buidBasePathDirectory = buildBasePath;
}
public static int Main(string[] args)
{
DebugHelper.HandleDebugSwitch(ref args);
var app = new CommandLineApplication(false)
{
Name = "dotnet restore",
FullName = ".NET project dependency restorer",
Description = "Restores dependencies listed in project.json"
};
app.OnExecute(() =>
{
try
{
var projectRestoreResult = Dnx.RunRestore(args);
var restoreTasks = GetRestoreTasks(args);
foreach (var restoreTask in restoreTasks)
{
var project = ProjectReader.GetProject(restoreTask.ProjectPath);
RestoreTools(project, restoreTask.Arguments);
}
return(projectRestoreResult);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
return(-1);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(-2);
}
});
return(app.Execute(args));
}
/// <summary>
/// Main entry point.
/// </summary>
/// <param name="args">The arguments.</param>
public static void Main(string[] args)
{
var resetmode = args.Contains("reset");
// Find the project root where glbal.json lives
var root = ProjectRootResolver.ResolveRootDirectory(".");
// Lets find the repo
var repo = new LibGit2Sharp.Repository(root);
// Lets find all the project.json files in the src folder (don't care about versioning `tests`)
var projectFiles = Directory.EnumerateFiles(Path.Combine(root, "src"), Project.FileName, SearchOption.AllDirectories);
// Open them and convert them to source projects
var projects = projectFiles.Select(x => ProjectReader.GetProject(x))
.Select(x => new SourceProject(x, repo.Info.WorkingDirectory))
.ToList();
if (resetmode)
{
ResetProject(projects);
}
else
{
CaclulateProjectVersionNumber(projects, repo);
UpdateVersionNumbers(projects);
CreateBuildScript(projects);
foreach (var p in projects)
{
Console.WriteLine($"{p.Name} {p.FinalVersionNumber}");
}
}
}
/// <summary>
/// The execution is done in 2 phases.
/// Phase 1 ::
/// 1. Determine if the tool is running as a project dependency or not.
/// 2. Try getting the project context for the project (use netcoreapp1.0 as the tfm if not running as dependency command or else use the tfm passed in)
/// 3. If not running as dependency command and project context cannot be built using netcoreapp1.0, invoke project dependency command with the first tfm found in the project.json
///
/// Phase 2 ::
/// 1. After successfully getting the Project context, invoke the CodeGenCommandExecutor.
/// </summary>
private static void Execute(string[] args)
{
var app = new CommandLineApplication(false)
{
Name = APPNAME,
Description = APP_DESC
};
// Define app Options;
app.HelpOption("-h|--help");
var projectPath = app.Option("-p|--project", "Path to project.json", CommandOptionType.SingleValue);
var packagesPath = app.Option("-n|--nuget-package-dir", "Path to check for Nuget packages", CommandOptionType.SingleValue);
var appConfiguration = app.Option("-c|--configuration", "Configuration for the project (Possible values: Debug/ Release)", CommandOptionType.SingleValue);
var framework = app.Option("-tfm|--target-framework", "Target Framework to use. (Short folder name of the tfm. eg. net451)", CommandOptionType.SingleValue);
var buildBasePath = app.Option("-b|--build-base-path", "", CommandOptionType.SingleValue);
var dependencyCommand = app.Option("--no-dispatch", "", CommandOptionType.NoValue);
app.OnExecute(() =>
{
string project = projectPath.Value();
if (string.IsNullOrEmpty(project))
{
project = Directory.GetCurrentDirectory();
}
var configuration = appConfiguration.Value() ?? Constants.DefaultConfiguration;
var projectFile = ProjectReader.GetProject(project);
var frameworksInProject = projectFile.GetTargetFrameworks().Select(f => f.FrameworkName);
var nugetFramework = FrameworkConstants.CommonFrameworks.NetCoreApp10;
if (_isDispatcher)
{
// Invoke the tool from the project's build directory.
return(BuildAndDispatchDependencyCommand(
args,
frameworksInProject.FirstOrDefault(),
project,
buildBasePath.Value(),
configuration));
}
else
{
if (!TryGetNugetFramework(framework.Value(), out nugetFramework))
{
throw new ArgumentException($"Could not understand the NuGetFramework information. Framework short folder name passed in was: {framework.Value()}");
}
var nearestNugetFramework = NuGetFrameworkUtility.GetNearest(
frameworksInProject,
nugetFramework,
f => new NuGetFramework(f));
if (nearestNugetFramework == null)
{
// This should never happen as long as we dispatch correctly.
var msg = "Could not find a compatible framework to execute."
+ Environment.NewLine
+ $"Available frameworks in project:{string.Join($"{Environment.NewLine} -", frameworksInProject.Select(f => f.GetShortFolderName()))}";
throw new InvalidOperationException(msg);
}
ProjectContext context = new ProjectContextBuilder()
.WithProject(projectFile)
.WithTargetFramework(nearestNugetFramework)
.Build();
Debug.Assert(context != null);
var codeGenArgs = ToolCommandLineHelper.FilterExecutorArguments(args);
CodeGenCommandExecutor executor = new CodeGenCommandExecutor(
context,
codeGenArgs,
configuration,
packagesPath.Value(),
_logger);
return(executor.Execute());
}
});
app.Execute(args);
}
public static CommandLineApplication Create()
{
var app = new CommandLineApplication(throwOnUnexpectedArg: false)
{
Name = "dotnet ef",
FullName = "Entity Framework .NET Core CLI Commands Dispatcher"
};
var noBuildOption = app.Option("--no-build", "Do not build before executing");
var configurationOption = app.Option(
"-c|--configuration <CONFIGURATION>",
"Configuration under which to load");
var frameworkOption = app.Option(
"-f|--framework <FRAMEWORK>",
"Target framework to load");
var buildBasePathOption = app.Option(
"-b|--build-base-path <OUTPUT_DIR>",
"Directory in which to find temporary outputs");
var outputOption = app.Option(
"-o|--output <OUTPUT_DIR>",
"Directory in which to find outputs");
app.OnExecute(() =>
{
var project = Directory.GetCurrentDirectory();
Reporter.Verbose.WriteLine(ToolsStrings.LogUsingProject(project));
var projectFile = ProjectReader.GetProject(project);
var framework = frameworkOption.HasValue()
? NuGetFramework.Parse(frameworkOption.Value())
: null;
if (framework == null)
{
var frameworks = projectFile.GetTargetFrameworks().Select(i => i.FrameworkName);
framework = NuGetFrameworkUtility.GetNearest(frameworks, FrameworkConstants.CommonFrameworks.NetCoreApp10, f => f)
?? frameworks.FirstOrDefault();
Reporter.Verbose.WriteLine(ToolsStrings.LogUsingFramework(framework.GetShortFolderName()));
}
var configuration = configurationOption.Value();
if (configuration == null)
{
configuration = Constants.DefaultConfiguration;
Reporter.Verbose.WriteLine(ToolsStrings.LogUsingConfiguration(configuration));
}
if (!noBuildOption.HasValue())
{
var buildExitCode = BuildCommandFactory.Create(
projectFile.ProjectFilePath,
configuration,
framework,
buildBasePathOption.Value(),
outputOption.Value())
.ForwardStdErr()
.ForwardStdOut()
.Execute()
.ExitCode;
if (buildExitCode != 0)
{
throw new OperationException(ToolsStrings.BuildFailed(projectFile.Name));
}
}
Reporter.Verbose.WriteLine(ToolsStrings.LogBeginDispatch(ProjectDependencyToolName, projectFile.Name));
try
{
bool isVerbose;
bool.TryParse(Environment.GetEnvironmentVariable(CommandContext.Variables.Verbose), out isVerbose);
var dispatchArgs = ExecuteCommand
.CreateArgs(framework, configuration, buildBasePathOption.Value(), noBuildOption.HasValue(), isVerbose)
.Concat(app.RemainingArguments);
return(DotnetToolDispatcher.CreateDispatchCommand(
dispatchArgs,
framework,
configuration,
outputPath: outputOption.Value(),
buildBasePath: buildBasePathOption.Value(),
projectDirectory: projectFile.ProjectDirectory,
toolName: ProjectDependencyToolName)
.ForwardStdErr()
.ForwardStdOut()
.Execute()
.ExitCode);
}
catch (CommandUnknownException ex)
{
Reporter.Verbose.WriteLine(ex.Message);
// intentionally put DispatcherToolName in error because "Microsoft.EntityFrameworkCore.Tools.Cli" is
// brought in automatically as a dependency of "Microsoft.EntityFrameworkCore.Tools"
Reporter.Error.WriteLine(ToolsStrings.ProjectDependencyCommandNotFound(DispatcherToolName));
return(1);
}
});
return(app);
}
public OperationExecutor(
[NotNull] CommonOptions options,
[CanBeNull] string startupProjectPath,
[CanBeNull] string environment)
{
var projectFile = Path.Combine(Directory.GetCurrentDirectory(), Project.FileName);
var project = ProjectReader.GetProject(projectFile);
startupProjectPath = startupProjectPath ?? projectFile;
var projectConfiguration = options.Configuration ?? Constants.DefaultConfiguration;
var projectFramework = options.Framework;
var startupConfiguration = options.Configuration ?? Constants.DefaultConfiguration;
var startupProjectContext = GetCompatibleStartupProjectContext(startupProjectPath, projectFramework);
var startupFramework = startupProjectContext.TargetFramework;
var externalStartup = project.ProjectFilePath != startupProjectContext.ProjectFile.ProjectFilePath;
if (externalStartup && !options.NoBuild)
{
Reporter.Verbose.WriteLine(ToolsCliStrings.LogBuildFailed.Bold().Black());
var buildExitCode = BuildCommandFactory.Create(startupProjectPath,
startupConfiguration,
startupFramework,
options.BuildBasePath,
output: null)
.ForwardStdOut()
.ForwardStdErr()
.Execute()
.ExitCode;
if (buildExitCode != 0)
{
throw new OperationException(ToolsCliStrings.LogBuildFailed);
}
Reporter.Verbose.WriteLine(ToolsCliStrings.LogBuildSucceeded.Bold().Black());
}
var runtimeOutputPath = startupProjectContext.GetOutputPaths(startupConfiguration)?.RuntimeOutputPath;
if (!string.IsNullOrEmpty(runtimeOutputPath))
{
Reporter.Verbose.WriteLine(
ToolsCliStrings.LogDataDirectory(runtimeOutputPath));
Environment.SetEnvironmentVariable(DataDirEnvName, runtimeOutputPath);
#if NET451
AppDomain.CurrentDomain.SetData("DataDirectory", runtimeOutputPath);
#endif
}
var startupAssemblyName = startupProjectContext.ProjectFile.GetCompilerOptions(startupFramework, startupConfiguration).OutputName;
var assemblyName = project.GetCompilerOptions(projectFramework, projectConfiguration).OutputName;
var projectDir = project.ProjectDirectory;
var startupProjectDir = startupProjectContext.ProjectFile.ProjectDirectory;
var rootNamespace = project.Name;
var projectAssembly = Assembly.Load(new AssemblyName {
Name = assemblyName
});
#if NET451
// TODO use app domains
var startupAssemblyLoader = new AssemblyLoader(Assembly.Load);
#else
AssemblyLoader startupAssemblyLoader;
if (externalStartup)
{
var assemblyLoadContext = startupProjectContext.CreateLoadContext(
PlatformServices.Default.Runtime.GetRuntimeIdentifier(),
Constants.DefaultConfiguration);
startupAssemblyLoader = new AssemblyLoader(assemblyLoadContext.LoadFromAssemblyName);
}
else
{
startupAssemblyLoader = new AssemblyLoader(Assembly.Load);
}
#endif
var startupAssembly = startupAssemblyLoader.Load(startupAssemblyName);
_contextOperations = new LazyRef <DbContextOperations>(
() => new DbContextOperations(
new LoggerProvider(name => new ConsoleCommandLogger(name)),
projectAssembly,
startupAssembly,
environment,
startupProjectDir));
_databaseOperations = new LazyRef <DatabaseOperations>(
() => new DatabaseOperations(
new LoggerProvider(name => new ConsoleCommandLogger(name)),
startupAssemblyLoader,
startupAssembly,
environment,
projectDir,
startupProjectDir,
rootNamespace));
_migrationsOperations = new LazyRef <MigrationsOperations>(
() => new MigrationsOperations(
new LoggerProvider(name => new ConsoleCommandLogger(name)),
projectAssembly,
startupAssemblyLoader,
startupAssembly,
environment,
projectDir,
startupProjectDir,
rootNamespace));
}
public static CommandLineApplication Create()
{
var app = new CommandLineApplication(throwOnUnexpectedArg: false)
{
Name = "dotnet ef",
FullName = "Entity Framework .NET Core CLI Commands Dispatcher"
};
var noBuildOption = app.Option("--no-build", "Do not build before executing");
var configurationOption = app.Option(
"-c|--configuration <CONFIGURATION>",
"Configuration under which to load");
var frameworkOption = app.Option(
"-f|--framework <FRAMEWORK>",
"Target framework to load");
var buildBasePathOption = app.Option(
"-b|--build-base-path <OUTPUT_DIR>",
"Directory in which to find temporary outputs");
var outputOption = app.Option(
"-o|--output <OUTPUT_DIR>",
"Directory in which to find outputs");
app.OnExecute(() =>
{
var project = Directory.GetCurrentDirectory();
Reporter.Verbose.WriteLine(ToolsStrings.LogUsingProject(project));
var projectFile = ProjectReader.GetProject(project);
var framework = frameworkOption.HasValue()
? NuGetFramework.Parse(frameworkOption.Value())
: null;
if (framework == null)
{
var frameworks = projectFile.GetTargetFrameworks().Select(i => i.FrameworkName);
framework = NuGetFrameworkUtility.GetNearest(frameworks, FrameworkConstants.CommonFrameworks.NetCoreApp10, f => f)
?? frameworks.FirstOrDefault();
Reporter.Verbose.WriteLine(ToolsStrings.LogUsingFramework(framework.GetShortFolderName()));
}
var configuration = configurationOption.Value();
if (configuration == null)
{
configuration = Constants.DefaultConfiguration;
Reporter.Verbose.WriteLine(ToolsStrings.LogUsingConfiguration(configuration));
}
if (!noBuildOption.HasValue())
{
var buildExitCode = BuildCommandFactory.Create(
projectFile.ProjectFilePath,
configuration,
framework,
buildBasePathOption.Value(),
outputOption.Value())
.ForwardStdErr()
.ForwardStdOut()
.Execute()
.ExitCode;
if (buildExitCode != 0)
{
throw new OperationException(ToolsStrings.BuildFailed(projectFile.Name));
}
}
// TODO remove when https://github.com/dotnet/cli/issues/2645 is resolved
Func <bool> isClassLibrary = () =>
{
var projectContext = ProjectContext.Create(
projectFile.ProjectFilePath,
framework,
RuntimeEnvironmentRidExtensions.GetAllCandidateRuntimeIdentifiers());
var runtimeFiles = projectContext
.GetOutputPaths(configuration, buildBasePathOption.Value(), outputOption.Value())
?.RuntimeFiles;
return(runtimeFiles == null ||
(
framework.IsDesktop()
? !Directory.Exists(runtimeFiles.BasePath)
: !File.Exists(runtimeFiles.RuntimeConfigJson) || !File.Exists(runtimeFiles.DepsJson)
));
};
Reporter.Verbose.WriteLine(ToolsStrings.LogBeginDispatch(ProjectDependencyToolName, projectFile.Name));
try
{
bool isVerbose;
bool.TryParse(Environment.GetEnvironmentVariable(CommandContext.Variables.Verbose), out isVerbose);
var dispatchArgs = ExecuteCommand
.CreateArgs(framework, configuration, isVerbose)
.Concat(app.RemainingArguments);
return(DotnetToolDispatcher.CreateDispatchCommand(
dispatchArgs,
framework,
configuration,
outputPath: outputOption.Value(),
buildBasePath: buildBasePathOption.Value(),
projectDirectory: projectFile.ProjectDirectory,
toolName: ProjectDependencyToolName)
.ForwardStdErr()
.ForwardStdOut()
.Execute()
.ExitCode);
}
catch (CommandUnknownException ex)
{
Reporter.Verbose.WriteLine(ex.Message);
var fwlink = "http://go.microsoft.com/fwlink/?LinkId=798221";
if (isClassLibrary())
{
Reporter.Error.WriteLine(ToolsStrings.ClassLibrariesNotSupportedInCli(fwlink));
}
else
{
// intentionally put DispatcherToolName in error because "Microsoft.EntityFrameworkCore.Tools.Cli" is
// brought in automatically as a dependency of "Microsoft.EntityFrameworkCore.Tools"
Reporter.Error.WriteLine(ToolsStrings.ProjectDependencyCommandNotFound(DispatcherToolName, fwlink));
}
return(1);
}
});
return(app);
}