async Task RunProjectOpenTasks(Solution solution)
{
ProgressMonitor monitor = null;
try {
GroupedTaskRunnerInformation tasks = GetGroupedTask(solution);
if (tasks != null)
{
monitor = CreateProgressMonitor();
await RunBuildTasks(tasks, TaskRunnerBindEvent.ProjectOpened);
}
foreach (Project project in solution.GetAllProjects())
{
tasks = GetGroupedTask(project);
if (tasks != null)
{
if (monitor == null)
{
monitor = CreateProgressMonitor();
}
await RunBuildTasks(tasks, TaskRunnerBindEvent.ProjectOpened);
}
}
} finally {
monitor?.Dispose();
}
}
public void Dispose()
{
monitor?.EndTask();
monitor?.ReportSuccess("Done.");
monitor?.Dispose();
monitor = null;
}
public static void Push(GitRepository repo)
{
var dlg = new PushDialog(repo);
try {
if (MessageService.RunCustomDialog(dlg) != (int)Gtk.ResponseType.Ok)
{
return;
}
string remote = dlg.SelectedRemote;
string branch = dlg.SelectedRemoteBranch ?? repo.GetCurrentBranch();
ProgressMonitor monitor = VersionControlService.GetProgressMonitor(GettextCatalog.GetString("Pushing changes..."), VersionControlOperationType.Push);
ThreadPool.QueueUserWorkItem(delegate {
try {
repo.Push(monitor, remote, branch);
} catch (Exception ex) {
monitor.ReportError(ex.Message, ex);
} finally {
monitor.Dispose();
}
});
} finally {
dlg.Destroy();
dlg.Dispose();
}
}
static void WriteSummaryResults(ProgressMonitor monitor, int succeeded, int warnings, int errors)
{
monitor.Log.WriteLine();
int total = succeeded + warnings + errors;
//this might not be correct for languages where pluralization affects the other arguments
//but gettext doesn't really have an answer for sentences with multiple plurals
monitor.Log.WriteLine(
GettextCatalog.GetPluralString(
"{0} file processed total. {1} generated successfully, {2} with warnings, {3} with errors",
"{0} files processed total. {1} generated successfully, {2} with warnings, {3} with errors",
total,
total, succeeded, warnings, errors)
);
//ends the root task
monitor.EndTask();
if (errors > 0)
{
monitor.ReportError(GettextCatalog.GetString("Errors in file generation."), null);
}
else if (warnings > 0)
{
monitor.ReportSuccess(GettextCatalog.GetString("Warnings in file generation."));
}
else
{
monitor.ReportSuccess(GettextCatalog.GetString("Generated files successfully."));
}
monitor.Dispose();
}
void StopReporting()
{
if (monitor != null)
{
monitor.Dispose();
monitor = null;
}
}
public void Wakeup()
{
try {
tracker.EndTask();
tracker.Dispose();
} finally {
Finished();
}
}
internal static void GenerateMakefiles(SolutionFolderItem entry, Solution solution)
{
if (solution == null)
{
AlertButton generateMakefilesButton = new AlertButton(GettextCatalog.GetString("_Generate Makefiles"));
if (MessageService.AskQuestion(GettextCatalog.GetString("Generating Makefiles is not supported for single projects. Do you want to generate them for the full solution - '{0}' ?", entry.ParentSolution.Name),
AlertButton.Cancel,
generateMakefilesButton) == generateMakefilesButton)
{
solution = ((SolutionFolderItem)entry).ParentSolution;
}
else
{
return;
}
}
DeployContext ctx = null;
ProgressMonitor monitor = null;
GenerateMakefilesDialog dialog = new GenerateMakefilesDialog(solution);
try {
if (MessageService.RunCustomDialog(dialog) != (int)Gtk.ResponseType.Ok)
{
return;
}
SolutionDeployer deployer = new SolutionDeployer(dialog.GenerateAutotools);
if (deployer.HasGeneratedFiles(solution))
{
string msg = GettextCatalog.GetString("{0} already exist for this solution. Would you like to overwrite them?", dialog.GenerateAutotools ? "Autotools files" : "Makefiles");
if (MonoDevelop.Ide.MessageService.AskQuestion(msg, AlertButton.Cancel, AlertButton.OverwriteFile) != AlertButton.OverwriteFile)
{
return;
}
}
ctx = new DeployContext(new TarballDeployTarget(dialog.GenerateAutotools), "Linux", null);
monitor = IdeApp.Workbench.ProgressMonitors.GetToolOutputProgressMonitor(true);
deployer.GenerateFiles(ctx, solution, dialog.DefaultConfiguration, monitor);
} finally {
dialog.Destroy();
dialog.Dispose();
if (ctx != null)
{
ctx.Dispose();
}
if (monitor != null)
{
monitor.Dispose();
}
}
}
public async Task SaveAsync ()
{
ProgressMonitor monitor = IdeApp.Workbench.ProgressMonitors.GetSaveProgressMonitor (true);
try {
await SaveAsync (monitor);
monitor.ReportSuccess (GettextCatalog.GetString ("Workspace saved."));
} catch (Exception ex) {
monitor.ReportError (GettextCatalog.GetString ("Save failed."), ex);
} finally {
monitor.Dispose ();
}
}
void UpdateTranslationsAsync(ProgressMonitor monitor, TranslationProject project)
{
try {
project.UpdateTranslations(monitor);
Gtk.Application.Invoke((o, args) => {
POEditorWidget.ReloadWidgets();
});
} catch (Exception ex) {
monitor.ReportError(GettextCatalog.GetString("Translation update failed."), ex);
} finally {
monitor.Log.WriteLine();
monitor.Log.WriteLine(GettextCatalog.GetString("---------------------- Done ----------------------"));
monitor.Dispose();
}
}
public void Run(ProgressMonitorStatusMessage progressMessage)
{
using (ProgressMonitor progressMonitor = CreateProgressMonitor(progressMessage)) {
using (PackageManagementEventsMonitor eventMonitor = CreateEventMonitor(progressMonitor)) {
try {
RestorePackages(progressMonitor, progressMessage);
} catch (Exception ex) {
LoggingService.LogError(progressMessage.Error, ex);
progressMonitor.Log.WriteLine(ex.Message);
progressMonitor.ReportError(progressMessage.Error, null);
progressMonitor.ShowPackageConsole();
progressMonitor.Dispose();
RestoreFailed = true;
}
}
}
}
void RunExternalTool(ExternalTools.ExternalTool tool, string argumentsTool)
{
string commandTool = StringParserService.Parse(tool.Command, IdeApp.Workbench.GetStringTagModel());
string initialDirectoryTool = StringParserService.Parse(tool.InitialDirectory, IdeApp.Workbench.GetStringTagModel());
//Execute tool
ProgressMonitor progressMonitor = IdeApp.Workbench.ProgressMonitors.GetRunProgressMonitor();
try {
progressMonitor.Log.WriteLine(GettextCatalog.GetString("Running: {0} {1}", (commandTool), (argumentsTool)));
progressMonitor.Log.WriteLine();
ProcessWrapper processWrapper;
if (tool.UseOutputPad)
{
processWrapper = Runtime.ProcessService.StartProcess(commandTool, argumentsTool, initialDirectoryTool, progressMonitor.Log, progressMonitor.Log, null);
}
else
{
processWrapper = Runtime.ProcessService.StartProcess(commandTool, argumentsTool, initialDirectoryTool, null);
}
string processName = System.IO.Path.GetFileName(commandTool);
try {
processName = processWrapper.ProcessName;
} catch (SystemException) {
}
processWrapper.WaitForOutput();
if (processWrapper.ExitCode == 0)
{
progressMonitor.Log.WriteLine(GettextCatalog.GetString("Process '{0}' has completed succesfully", processName));
}
else
{
progressMonitor.Log.WriteLine(GettextCatalog.GetString("Process '{0}' has exited with error code {1}", processName, processWrapper.ExitCode));
}
} catch (Exception ex) {
progressMonitor.ReportError(GettextCatalog.GetString("External program execution failed.\nError while starting:\n '{0} {1}'", commandTool, argumentsTool), ex);
} finally {
progressMonitor.Dispose();
}
}
public static async Task SaveSolutionAsync(this Solution solution)
{
ProgressMonitor monitor = IdeApp.Workbench.ProgressMonitors.GetLoadProgressMonitor(true);
try
{
await solution.SaveAsync(monitor);
monitor.ReportSuccess(GettextCatalog.GetString("Success."));
}
catch (Exception ex)
{
monitor.ReportError(GettextCatalog.GetString("Save failed."), ex);
}
finally
{
monitor.Dispose();
}
}
//static void OnFileChanged (object s, ProjectFileEventArgs args)
//{
// Repository repo = GetRepository (args.Project);
// if (repo != null)
// NotifyFileStatusChanged (repo, args.ProjectFile.FilePath, false);
//}
static async void OnFileAdded(object s, ProjectFileEventArgs e)
{
var vargs = new FileUpdateEventArgs();
ProgressMonitor monitor = null;
try {
foreach (var repoFiles in e.GroupBy(i => i.Project))
{
var repo = GetRepository(repoFiles.Key);
if (repo == null)
{
continue;
}
var filePaths = repoFiles.Where(ShouldAddFile).Select(f => f.ProjectFile.FilePath);
foreach (var file in filePaths)
{
if (monitor == null)
{
monitor = GetStatusMonitor();
}
var gotInfo = repo.TryGetVersionInfo(file, out var versionInfo);
if (gotInfo == false || (versionInfo.Status & VersionStatus.Ignored) == 0 && versionInfo.CanAdd)
{
await repo.AddAsync(file, false, monitor);
}
}
vargs.AddRange(repoFiles.Select(i => new FileUpdateEventInfo(repo, i.ProjectFile.FilePath, i.ProjectFile.Subtype == Subtype.Directory)));
}
if (vargs.Count > 0)
{
NotifyFileStatusChanged(vargs);
}
} catch (OperationCanceledException) {
return;
} catch (Exception ex) {
LoggingService.LogInternalError(ex);
} finally {
monitor?.Dispose();
}
}
public static void Push(GitRepository repo)
{
bool hasCommits = false;
using (var RootRepository = new LibGit2Sharp.Repository(repo.RootPath))
hasCommits = RootRepository.Commits.Any();
if (!hasCommits)
{
MessageService.ShowMessage(
GettextCatalog.GetString("There are no changes to push."),
GettextCatalog.GetString("Create an initial commit first.")
);
return;
}
var dlg = new PushDialog(repo);
try {
if (MessageService.RunCustomDialog(dlg) != (int)Gtk.ResponseType.Ok)
{
return;
}
string remote = dlg.SelectedRemote;
string branch = dlg.SelectedRemoteBranch ?? repo.GetCurrentBranch();
ProgressMonitor monitor = VersionControlService.GetProgressMonitor(GettextCatalog.GetString("Pushing changes..."), VersionControlOperationType.Push);
Task.Run(async() => {
try {
await repo.PushAsync(monitor, remote, branch);
} catch (Exception ex) {
monitor.ReportError(ex.Message, ex);
} finally {
monitor.Dispose();
}
});
} finally {
dlg.Destroy();
dlg.Dispose();
}
}
public void OnRestoreFinished(bool success)
{
concurrentRestoreCount--;
if (!success)
{
this.success = false;
}
if (concurrentRestoreCount <= 0)
{
if (this.success)
{
currentProgressMonitor.ReportSuccess(GettextCatalog.GetString("Dependencies restored successfully."));
}
else
{
currentProgressMonitor.ReportError(GettextCatalog.GetString("Could not restore dependencies."));
}
currentProgressMonitor.Dispose();
currentProgressMonitor = null;
}
}
//static void OnFileChanged (object s, ProjectFileEventArgs args)
//{
// Repository repo = GetRepository (args.Project);
// if (repo != null)
// NotifyFileStatusChanged (repo, args.ProjectFile.FilePath, false);
//}
static async void OnFileAdded(object s, ProjectFileEventArgs e)
{
var vargs = new FileUpdateEventArgs();
ProgressMonitor monitor = null;
try {
foreach (var repoFiles in e.GroupBy(i => i.Project))
{
var repo = GetRepository(repoFiles.Key);
if (repo == null)
{
continue;
}
var filePaths = repoFiles.Where(ShouldAddFile).Select(f => f.ProjectFile.FilePath);
var versionInfos = await repo.GetVersionInfoAsync(filePaths, VersionInfoQueryFlags.IgnoreCache).ConfigureAwait(false);
var paths = versionInfos.Where(i => i.CanAdd).Select(i => i.LocalPath).ToArray();
if (paths.Length > 0)
{
if (monitor == null)
{
monitor = GetStatusMonitor();
}
await repo.AddAsync(paths, false, monitor);
}
vargs.AddRange(repoFiles.Select(i => new FileUpdateEventInfo(repo, i.ProjectFile.FilePath, i.ProjectFile.Subtype == Subtype.Directory)));
}
if (vargs.Count > 0)
{
NotifyFileStatusChanged(vargs);
}
} catch (OperationCanceledException) {
return;
} catch (Exception ex) {
LoggingService.LogInternalError(ex);
} finally {
monitor?.Dispose();
}
}
//static void OnFileChanged (object s, ProjectFileEventArgs args)
//{
// Repository repo = GetRepository (args.Project);
// if (repo != null)
// NotifyFileStatusChanged (repo, args.ProjectFile.FilePath, false);
//}
static void OnFileAdded(object s, ProjectFileEventArgs e)
{
FileUpdateEventArgs vargs = new FileUpdateEventArgs();
ProgressMonitor monitor = null;
try {
foreach (var repoFiles in e.GroupBy(i => i.Project))
{
Repository repo = GetRepository(repoFiles.Key);
if (repo == null)
{
continue;
}
var filePaths = repoFiles.Where(ShouldAddFile).Select(f => f.ProjectFile.FilePath);
var versionInfos = repo.GetVersionInfo(filePaths, VersionInfoQueryFlags.IgnoreCache);
FilePath[] paths = versionInfos.Where(i => i.CanAdd).Select(i => i.LocalPath).ToArray();
if (paths.Length > 0)
{
if (monitor == null)
{
monitor = GetStatusMonitor();
}
repo.Add(paths, false, monitor);
}
vargs.AddRange(repoFiles.Select(i => new FileUpdateEventInfo(repo, i.ProjectFile.FilePath, i.ProjectFile.Subtype == Subtype.Directory)));
}
}
finally {
if (monitor != null)
{
monitor.Dispose();
}
}
if (vargs.Count > 0)
{
NotifyFileStatusChanged(vargs);
}
}
static bool UpdateCompleted(ProgressMonitor monitor,
ProjectFile file, ProjectFile genFile, SingleFileCustomToolResult result,
bool runMultipleFiles)
{
monitor.EndTask();
if (monitor.CancellationToken.IsCancellationRequested)
{
monitor.ReportError(GettextCatalog.GetString("Cancelled"), null);
monitor.Dispose();
return(false);
}
string genFileName;
try {
bool broken = false;
if (result.UnhandledException != null)
{
broken = true;
string msg = GettextCatalog.GetString("The '{0}' code generator crashed", file.Generator);
result.Errors.Add(new CompilerError(file.Name, 0, 0, "",
msg +
": " +
result.UnhandledException.Message +
Environment.NewLine +
result.UnhandledException.StackTrace));
monitor.ReportError(msg, result.UnhandledException);
LoggingService.LogError(msg, result.UnhandledException);
}
genFileName = result.GeneratedFilePath.IsNullOrEmpty?
null : result.GeneratedFilePath.ToRelative(file.FilePath.ParentDirectory);
if (!string.IsNullOrEmpty(genFileName))
{
bool validName = genFileName.IndexOfAny(new [] { '/', '\\' }) < 0 &&
FileService.IsValidFileName(genFileName);
if (!broken && !validName)
{
broken = true;
string msg = GettextCatalog.GetString("The '{0}' code generator output invalid filename '{1}'",
file.Generator, result.GeneratedFilePath);
result.Errors.Add(new CompilerError(file.Name, 0, 0, "", msg));
monitor.ReportError(msg, null);
}
}
if (result.Errors.Count > 0)
{
Runtime.RunInMainThread(delegate {
foreach (CompilerError err in result.Errors)
{
TaskService.Errors.Add(new TaskListEntry(file.FilePath, err.ErrorText, err.Column, err.Line,
err.IsWarning? TaskSeverity.Warning : TaskSeverity.Error,
TaskPriority.Normal, file.Project.ParentSolution, file));
}
});
}
if (broken)
{
return(true);
}
if (!runMultipleFiles)
{
if (result.Success)
{
monitor.ReportSuccess("Generated file successfully.");
}
else if (result.SuccessWithWarnings)
{
monitor.ReportSuccess("Warnings in file generation.");
}
else
{
monitor.ReportError("Errors in file generation.", null);
}
}
} finally {
if (!runMultipleFiles)
{
monitor.Dispose();
}
}
if (result.GeneratedFilePath.IsNullOrEmpty || !File.Exists(result.GeneratedFilePath))
{
return(true);
}
// broadcast a change event so text editors etc reload the file
FileService.NotifyFileChanged(result.GeneratedFilePath);
// add file to project, update file properties, etc
Gtk.Application.Invoke(async(o, args) => {
bool projectChanged = false;
if (genFile == null)
{
genFile = file.Project.AddFile(result.GeneratedFilePath, result.OverrideBuildAction);
projectChanged = true;
}
else if (result.GeneratedFilePath != genFile.FilePath)
{
genFile.Name = result.GeneratedFilePath;
projectChanged = true;
}
if (file.LastGenOutput != genFileName)
{
file.LastGenOutput = genFileName;
projectChanged = true;
}
if (genFile.DependsOn != file.FilePath.FileName)
{
genFile.DependsOn = file.FilePath.FileName;
projectChanged = true;
}
if (projectChanged)
{
await IdeApp.ProjectOperations.SaveAsync(file.Project);
}
});
return(true);
}