protected override Task OnExecute(
ProgressMonitor monitor,
ExecutionContext context,
ConfigurationSelector configuration,
SolutionItemRunConfiguration runConfiguration)
{
TargetFrameworkMoniker framework = Project.TargetFramework.Id;
if (Project.HasMultipleTargetFrameworks)
{
var frameworkContext = context?.ExecutionTarget as AspNetCoreTargetFrameworkExecutionTarget;
if (frameworkContext != null)
{
framework = frameworkContext.Framework;
if (!(configuration is DotNetProjectFrameworkConfigurationSelector))
{
configuration = new DotNetProjectFrameworkConfigurationSelector(configuration, frameworkContext.FrameworkShortName);
}
}
}
if (IsSupportedFramework(framework))
{
return(OnExecute(monitor, context, configuration, framework, runConfiguration));
}
return(base.OnExecute(monitor, context, configuration, runConfiguration));
}
/// <summary>
/// Only supported projects should be checked. If the development certificate
/// was found to be trusted then do not check again for the current IDE session.
/// </summary>
public static bool CheckDevelopmentCertificateIsTrusted (DotNetProject project, SolutionItemRunConfiguration runConfiguration)
{
if (IsDevelopmentCertificateTrusted) {
return false;
}
return IsProjectSupported (project, runConfiguration);
}
/// <summary>
/// Only .NET Core 2.1 projects and higher are supported.
/// Also need .NET Core SDK 2.1 or higher to be installed.
/// Also check if the project is using https.
/// </summary>
public static bool IsProjectSupported (DotNetProject project, SolutionItemRunConfiguration runConfiguration)
{
if (!Platform.IsMac) {
// Only Mac supported currently.
return false;
}
return project.TargetFramework.IsNetCoreAppOrHigher (MinimumCoreRuntime) &&
IsNetCoreSdk21OrHigherInstalled () &&
UsingHttps (runConfiguration);
}
/// <summary>
/// Only .NET Core 2.1 projects are supported.
/// Also need .NET Core SDK 2.1 to be installed.
/// Also check if the project is using https.
/// </summary>
public static bool IsProjectSupported(DotNetProject project, SolutionItemRunConfiguration runConfiguration)
{
if (!Platform.IsMac)
{
// Only Mac supported currently.
return(false);
}
return(project.TargetFramework.IsNetCoreApp21() &&
IsNetCoreSdk21Installed() &&
UsingHttps(runConfiguration));
}
protected override Task OnExecute(
ProgressMonitor monitor,
ExecutionContext context,
ConfigurationSelector configuration,
TargetFrameworkMoniker framework,
SolutionItemRunConfiguration runConfiguration)
{
if (DotNetCoreRuntime.IsInstalled)
{
return(CheckCertificateThenExecute(monitor, context, configuration, framework, runConfiguration));
}
return(base.OnExecute(monitor, context, configuration, framework, runConfiguration));
}
async Task CheckCertificateThenExecute(
ProgressMonitor monitor,
ExecutionContext context,
ConfigurationSelector configuration,
TargetFrameworkMoniker framework,
SolutionItemRunConfiguration runConfiguration)
{
if (AspNetCoreCertificateManager.CheckDevelopmentCertificateIsTrusted(Project, runConfiguration))
{
await AspNetCoreCertificateManager.TrustDevelopmentCertificate(monitor);
}
await base.OnExecute(monitor, context, configuration, framework, runConfiguration);
}
// called by the IDE to determine whether or not the currently selected project and
// device in the toolbar is good to go for deployment and execution.
protected override bool OnGetCanExecute(
ExecutionContext context,
ConfigurationSelector configuration,
SolutionItemRunConfiguration runConfiguration)
{
// find the selected solution's startup project
if (IdeApp.Workspace.GetAllSolutions().Any((s) => s.StartupItem == this.Project))
{
// if the selection execution target is a meadow device, and the project is an executable.
return(context.ExecutionTarget is MeadowDeviceExecutionTarget && base.OnGetCanExecute(context, configuration, runConfiguration));
}
return(base.OnGetCanExecute(context, configuration, runConfiguration));
}
protected override Task OnExecute(
ProgressMonitor monitor,
ExecutionContext context,
ConfigurationSelector configuration,
TargetFrameworkMoniker framework,
SolutionItemRunConfiguration runConfiguration)
{
if (DotNetCoreRuntime.IsMissing)
{
return(ShowCannotExecuteDotNetCoreApplicationDialog());
}
return(base.OnExecute(monitor, context, configuration, framework, runConfiguration));
}
protected override Task OnExecute(
ProgressMonitor monitor,
ExecutionContext context,
ConfigurationSelector configuration,
TargetFrameworkMoniker framework,
SolutionItemRunConfiguration runConfiguration)
{
var requiredVersion = DotNetCoreVersion.Parse(Project.TargetFramework.Id.Version);
if (DotNetCoreRuntime.IsMissing)
{
return(ShowCannotExecuteDotNetCoreApplicationDialog(DotNetCoreRuntime.GetNotInstalledVersionMessage(requiredVersion.OriginalString), requiredVersion));
}
if (Project.TargetFramework.IsNetCoreApp() &&
!DotNetCoreRuntime.Versions.Any(x => x.OriginalString.StartsWith(Project.TargetFramework.Id.Version, StringComparison.OrdinalIgnoreCase)))
{
return(ShowCannotExecuteDotNetCoreApplicationDialog(DotNetCoreRuntime.GetNotInstalledVersionMessage(requiredVersion.OriginalString), requiredVersion));
}
return(base.OnExecute(monitor, context, configuration, framework, runConfiguration));
}
/// <summary>
/// Load configuration information for a solution
/// </summary>
public void Load(Solution sol, SolutionItem project, SolutionItemRunConfiguration runConfig)
{
currentSolutionConfigurations.Clear();
currentTargetPartitions.Clear();
reducedConfigurations.Clear();
if (sol == null)
{
return;
}
// Create a set of configuration partitions. Each partition will contain configurations
// which are implicitly selected when selecting an execution target. For example, in
// an iOS project we would have two partitions:
// 1) Debug|IPhoneSimulator, Release|IPhoneSimulator
// targets: iPhone, iPad
// 2) Debug|IPhone, Release|IPhone
// targets: device
List <TargetPartition> partitions = new List <TargetPartition> ();
if (project != null)
{
foreach (var conf in project.Configurations)
{
var targets = project.GetExecutionTargets(conf.Selector, runConfig);
if (!targets.Any())
{
targets = new ExecutionTarget[] { dummyExecutionTarget };
}
var parts = partitions.Where(p => targets.Any(p.Targets.Contains)).ToArray();
if (parts.Length == 0)
{
// Create a new partition for this configuration
var p = new TargetPartition();
p.Configurations.Add(conf.Id);
p.Targets.UnionWith(targets);
partitions.Add(p);
}
else if (parts.Length == 1)
{
// Register the configuration into an existing partition
parts[0].Configurations.Add(conf.Id);
parts[0].Targets.UnionWith(targets);
}
else
{
// The partitions have to be merged into a single one
for (int n = 1; n < parts.Length; n++)
{
parts[0].Configurations.UnionWith(parts[n].Configurations);
parts[0].Targets.UnionWith(parts[n].Targets);
partitions.Remove(parts[n]);
}
}
}
// The startup project configuration partitions are used to create solution configuration partitions
foreach (var solConf in sol.Configurations)
{
var pconf = solConf.GetEntryForItem(project);
if (pconf != null && pconf.Build)
{
var part = partitions.FirstOrDefault(p => p.Configurations.Contains(pconf.ItemConfiguration));
if (part != null)
{
part.SolutionConfigurations.Add(solConf.Id);
continue;
}
}
// The solution configuration is not bound to the startup project
// Add it to all partitions so that it can still take part of
// the solution configuration simplification process
foreach (var p in partitions)
{
p.SolutionConfigurations.Add(solConf.Id);
}
}
}
if (partitions.Count == 0)
{
// There is no startup project, just use all solution configurations in this case
var p = new TargetPartition();
p.SolutionConfigurations.AddRange(sol.GetConfigurations());
partitions.Add(p);
}
// There can be several configurations with the same prefix and different platform but which build the same projects.
// If all configurations with the same prefix are identical, all of them can be reduced into a single configuration
// with no platform name. This loop detects such configurations
var notReducibleConfigurations = new HashSet <string> ();
foreach (var p in partitions)
{
var groupedConfigs = p.SolutionConfigurations.GroupBy(sc => {
string name, plat;
ItemConfiguration.ParseConfigurationId(sc, out name, out plat);
return(name);
}).ToArray();
foreach (var confGroup in groupedConfigs)
{
var configs = confGroup.ToArray();
var baseConf = sol.Configurations[configs[0]];
if (configs.Skip(1).All(c => ConfigurationEquals(sol, baseConf, sol.Configurations[c])))
{
p.ReducedConfigurations.Add(confGroup.Key);
}
else
{
notReducibleConfigurations.Add(confGroup.Key);
}
}
}
// To really be able to use reduced configuration names, all partitions must have that reduced configuration
// Find the configurations that have been reduced in all partitions
reducedConfigurations = new HashSet <string> (partitions.SelectMany(p => p.ReducedConfigurations));
reducedConfigurations.ExceptWith(notReducibleConfigurations);
// Final merge of configurations
var result = new HashSet <string> ();
foreach (var p in partitions)
{
result.UnionWith(p.SolutionConfigurations);
}
// Replace reduced configurations
foreach (var reducedConf in reducedConfigurations)
{
result.RemoveWhere(c => {
string name, plat;
ItemConfiguration.ParseConfigurationId(c, out name, out plat);
return(name == reducedConf);
});
result.Add(reducedConf);
}
currentTargetPartitions = partitions;
currentSolutionConfigurations.AddRange(result);
currentSolutionConfigurations.Sort();
}
protected override bool OnGetCanExecute(Projects.ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
return(false);
}
protected async override Task OnExecute(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
//check XSP is available
var cfg = GetConfiguration(configuration);
var cmd = CreateExecutionCommand(configuration, cfg);
var browserExcTarget = context.ExecutionTarget as BrowserExecutionTarget;
OperationConsole console = null;
bool isXsp = true; //FIXME: fix this when it might not be true - should delegate to the ExecutionHandler
try {
//HACK: check XSP exists first, because error UX is cleaner w/o displaying a blank console pad.
if (isXsp)
{
try {
AspNetExecutionHandler.GetXspPath((AspNetExecutionCommand)cmd);
} catch (UserException ex) {
MessageService.ShowError(
GettextCatalog.GetString("Could not launch ASP.NET web server"),
ex.Message);
throw;
}
}
console = context.ConsoleFactory.CreateConsole(monitor.CancellationToken);
// The running Port value is now captured in the XspBrowserLauncherConsole object
string url = String.Format("http://{0}", XspParameters.Address);
if (isXsp)
{
console = new XspBrowserLauncherConsole(console, delegate(string port) {
if (browserExcTarget != null)
{
browserExcTarget.DesktopApp.Launch(String.Format("{0}:{1}", url, port));
}
else
{
BrowserLauncher.LaunchDefaultBrowser(String.Format("{0}:{1}", url, port));
}
});
}
monitor.Log.WriteLine(GettextCatalog.GetString("Running web server..."));
var op = context.ExecutionHandler.Execute(cmd, console);
if (!isXsp)
{
if (browserExcTarget != null)
{
browserExcTarget.DesktopApp.Launch(url);
}
else
{
BrowserLauncher.LaunchDefaultBrowser(url);
}
}
using (monitor.CancellationToken.Register(op.Cancel))
await op.Task;
monitor.Log.WriteLine(GettextCatalog.GetString("The web server exited with code: {0}", op.ExitCode));
} catch (Exception ex) {
if (!(ex is UserException))
{
LoggingService.LogError("Could not launch ASP.NET web server.", ex);
}
monitor.ReportError(GettextCatalog.GetString("Could not launch web server."), ex);
} finally {
if (console != null)
{
console.Dispose();
}
}
}
protected override Task OnExecute(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
if (!IdeApp.Preferences.BuildBeforeExecuting && !IsDotNetCoreInstalled())
{
return(ShowCannotExecuteDotNetCoreApplicationDialog());
}
return(base.OnExecute(monitor, context, configuration, runConfiguration));
}
protected override bool OnGetCanExecute(ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
if (IdeApp.Workspace.GetAllSolutions().Any((s) => s.StartupItem == this.Project))
{
return(context.ExecutionTarget is MicroFrameworkExecutionTarget && base.OnGetCanExecute(context, configuration, runConfiguration));
}
else
{
return(base.OnGetCanExecute(context, configuration, runConfiguration));
}
}
protected override IEnumerable <ExecutionTarget> OnGetExecutionTargets(OperationContext ctx, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfig)
{
if (IsWeb)
{
var result = new ExecutionTargetGroup(GettextCatalog.GetString("Browser"), "MonoDevelop.AspNetCore.BrowserExecutionTargets");
foreach (var browser in IdeServices.DesktopService.GetApplications("https://localhost", Ide.Desktop.DesktopApplicationRole.Viewer))
{
if (browser.IsDefault)
{
if (Project.HasMultipleTargetFrameworks)
{
result.InsertRange(0, GetMultipleTargetFrameworkExecutionTargets(browser));
}
else
{
result.Insert(0, new AspNetCoreExecutionTarget(browser));
}
}
else
{
if (Project.HasMultipleTargetFrameworks)
{
result.AddRange(GetMultipleTargetFrameworkExecutionTargets(browser));
}
else
{
result.Add(new AspNetCoreExecutionTarget(browser));
}
}
}
return(result.Count > 0
? new ExecutionTarget [] { result }
: base.OnGetExecutionTargets(ctx, configuration, runConfig));
}
else
{
return(base.OnGetExecutionTargets(ctx, configuration, runConfig));
}
}
protected override async Task OnExecute(MonoDevelop.Core.ProgressMonitor monitor, MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
if (runConfiguration == unitTestingRunConfigurationInstance)
{
// The user selected to run the tests
UnitTest test = FindRootTest();
if (test != null)
{
var cs = new CancellationTokenSource();
using (monitor.CancellationToken.Register(cs.Cancel))
await UnitTestService.RunTest(test, context, false, false, cs);
}
}
else
{
await base.OnExecute(monitor, context, configuration, runConfiguration);
}
}
protected override bool OnGetCanExecute(ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
var cmd = CreateExecutionCommand();
return(context.ExecutionHandler.CanExecute(cmd));
}
protected override bool OnGetCanExecute(ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
if (IsGodotProject())
{
return(true);
}
return(base.OnGetCanExecute(context, configuration, runConfiguration));
}
protected override bool OnGetCanExecute(ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
return(IsAddin);
}
protected override bool OnGetCanExecute(ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
if (data != null && data.SupportsIntegration && !String.IsNullOrEmpty(data.ExecuteTargetName))
{
return(true);
}
return(base.OnGetCanExecute(context, configuration, runConfiguration));
}
protected async override Task OnExecute(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
if (data == null || !data.SupportsIntegration || String.IsNullOrEmpty(data.ExecuteTargetName))
{
await base.OnExecute(monitor, context, configuration, runConfiguration);
return;
}
OperationConsole console = context.ConsoleFactory.CreateConsole();
monitor.BeginTask(GettextCatalog.GetString("Executing {0}", Project.Name), 1);
try
{
ProcessWrapper process = Runtime.ProcessService.StartProcess("make",
data.ExecuteTargetName,
Project.BaseDirectory,
console.Out,
console.Error,
null);
await process.Task;
monitor.Log.WriteLine(GettextCatalog.GetString("The application exited with code: {0}", process.ExitCode));
monitor.Step(1);
} catch (Exception e) {
monitor.ReportError(GettextCatalog.GetString("Project could not be executed: "), e);
return;
} finally {
monitor.EndTask();
console.Dispose();
}
}
public abstract void Load(Project project, SolutionItemRunConfiguration config);
public override void Load(Project project, SolutionItemRunConfiguration config)
{
widget.Load((ProcessRunConfiguration)config);
}
protected override IEnumerable <ExecutionTarget> OnGetExecutionTargets(OperationContext ctx, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfig)
{
var result = new List <ExecutionTarget> ();
foreach (var browser in IdeServices.DesktopService.GetApplications("https://localhost", Ide.Desktop.DesktopApplicationRole.Viewer))
{
if (browser.IsDefault)
{
if (Project.HasMultipleTargetFrameworks)
{
result.InsertRange(0, GetMultipleTargetFrameworkExecutionTargets(browser));
}
else
{
result.Insert(0, new AspNetCoreExecutionTarget(browser));
}
}
else
{
if (Project.HasMultipleTargetFrameworks)
{
result.AddRange(GetMultipleTargetFrameworkExecutionTargets(browser));
}
else
{
result.Add(new AspNetCoreExecutionTarget(browser));
}
}
}
return(result.Count > 0 ? result : base.OnGetExecutionTargets(configuration));
}
static bool UsingHttps(SolutionItemRunConfiguration runConfiguration)
{
var aspNetCoreRunConfiguration = runConfiguration as AspNetCoreRunConfiguration;
return(aspNetCoreRunConfiguration?.UsingHttps() == true);
}
public override void Load(Project project, SolutionItemRunConfiguration config)
{
widget.LoadCore(project, (AspNetCoreRunConfiguration)config);
widget.Changed += (sender, e) => NotifyChanged();
}
protected async override System.Threading.Tasks.Task OnExecute(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
var cmd = CreateExecutionCommand();
cmd.Target = context.ExecutionTarget;
var console = context.ConsoleFactory.CreateConsole(monitor.CancellationToken);
var operation = context.ExecutionHandler.Execute(cmd, console);
using (monitor.CancellationToken.Register(operation.Cancel))
{
await operation.Task;
}
}
protected override bool OnGetCanExecute(ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
if (!IsSupportedProject)
{
return(base.OnGetCanExecute(context, configuration, runConfiguration));
}
// need to call base regardless to set context.RunConfiguration properly.
// this is probably a flaw in the API design, we really shouldn't need this (it wasn't required with the old API).
// without this, the breakpoint options dialog does not allow you to set conditions, etc.
base.OnGetCanExecute(context, configuration, runConfiguration);
return(true);
}
protected override bool OnGetCanExecute(MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
if (runConfiguration == unitTestingRunConfigurationInstance)
{
UnitTest test = FindRootTest();
return((test != null) && test.CanRun(context.ExecutionHandler));
}
return(base.OnGetCanExecute(context, configuration, runConfiguration));
}
/// <summary>
/// Executes the project
/// </summary>
/// <param name="monitor">Progress monitor.</param>
/// <param name="context">Execution context.</param>
/// <param name="configuration">Configuration to execute.</param>
/// <returns>The execute.</returns>
protected async override Task DoExecute(ProgressMonitor monitor, MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
var conf = (CProjectConfiguration)GetConfiguration(configuration);
bool pause = conf.PauseConsoleOutput;
OperationConsole console;
if (conf.CompileTarget != CompileTarget.Exe)
{
MessageService.ShowMessage("Compile target is not an executable!");
return;
}
monitor.Log.WriteLine("Running project...");
if (conf.ExternalConsole)
{
console = context.ExternalConsoleFactory.CreateConsole(!pause, monitor.CancellationToken);
}
else
{
console = context.ConsoleFactory.CreateConsole(monitor.CancellationToken);
}
try {
ExecutionCommand cmd = CreateExecutionCommand(conf);
if (!context.ExecutionHandler.CanExecute(cmd))
{
monitor.ReportError("Cannot execute \"" + conf.Output + "\". The selected execution mode is not supported for C projects.", null);
return;
}
ProcessAsyncOperation op = context.ExecutionHandler.Execute(cmd, console);
using (var t = monitor.CancellationToken.Register(op.Cancel))
await op.Task;
monitor.Log.WriteLine("The operation exited with code: {0}", op.ExitCode);
} catch (Exception ex) {
LoggingService.LogError(string.Format("Cannot execute \"{0}\"", conf.Output), ex);
monitor.ReportError("Cannot execute \"" + conf.Output + "\"", ex);
} finally {
console.Dispose();
}
}
