public void RunXslTransformCommand() { if (string.IsNullOrEmpty(stylesheetFileName)) { stylesheetFileName = XmlEditorService.BrowseForStylesheetFile(); if (string.IsNullOrEmpty(stylesheetFileName)) { return; } } using (ProgressMonitor monitor = XmlEditorService.GetMonitor()) { try { string xsltContent; try { xsltContent = GetFileContent(stylesheetFileName); } catch (System.IO.IOException) { monitor.ReportError( GettextCatalog.GetString("Error reading file '{0}'.", stylesheetFileName), null); return; } System.Xml.Xsl.XslCompiledTransform xslt = XmlEditorService.ValidateStylesheet(monitor, xsltContent, stylesheetFileName); if (xslt == null) { return; } XmlDocument doc = XmlEditorService.ValidateXml(monitor, Editor.Text, FileName); if (doc == null) { return; } string newFileName = XmlEditorService.GenerateFileName(FileName, "-transformed{0}.xml"); monitor.BeginTask(GettextCatalog.GetString("Executing transform..."), 1); using (XmlTextWriter output = XmlEditorService.CreateXmlTextWriter(Editor)) { xslt.Transform(doc, null, output); IdeApp.Workbench.NewDocument( newFileName, "application/xml", output.ToString()); } monitor.ReportSuccess(GettextCatalog.GetString("Transform completed.")); monitor.EndTask(); } catch (Exception ex) { string msg = GettextCatalog.GetString("Could not run transform."); monitor.ReportError(msg, ex); monitor.EndTask(); } } }
public void RunXslTransformCommand() { if (string.IsNullOrEmpty(stylesheetFileName)) { stylesheetFileName = XmlEditorService.BrowseForStylesheetFile(); if (string.IsNullOrEmpty(stylesheetFileName)) { return; } } using (ProgressMonitor monitor = XmlEditorService.GetMonitor()) { try { string xsltContent; try { xsltContent = GetFileContent(stylesheetFileName); } catch (IOException) { monitor.ReportError( GettextCatalog.GetString("Error reading file '{0}'.", stylesheetFileName), null); return; } (var xslt, var errors) = XmlEditorService.CompileStylesheet(xsltContent, stylesheetFileName); if (xslt == null) { monitor.ReportError(GettextCatalog.GetString("Failed to compile stylesheet")); return; } string newFileName = XmlEditorService.GenerateFileName(FileName, "-transformed{0}.xml"); monitor.BeginTask(GettextCatalog.GetString("Executing transform..."), 1); var output = new EncodedStringWriter(Encoding.UTF8); using (XmlReader input = XmlReader.Create(new StringReader(Editor.Text), null, FileName)) { using (XmlTextWriter writer = XmlEditorService.CreateXmlTextWriter(Editor, output)) { xslt.Transform(input, writer); } } IdeApp.Workbench.NewDocument(newFileName, "application/xml", output.ToString()); monitor.ReportSuccess(GettextCatalog.GetString("Transform completed.")); monitor.EndTask(); } catch (Exception ex) { string msg = GettextCatalog.GetString("Could not run transform."); monitor.ReportError(msg, ex); monitor.EndTask(); } } }
void InstallEntry(ProgressMonitor monitor, DeployContext ctx, SolutionFolderItem entry, ConfigurationSelector configuration) { foreach (DeployFile df in DeployService.GetDeployFiles(ctx, new SolutionFolderItem[] { entry }, configuration)) { string targetPath = df.ResolvedTargetFile; if (targetPath == null) { monitor.ReportWarning("Could not copy file '" + df.RelativeTargetPath + "': Unknown target directory."); continue; } CopyFile(monitor, df.SourcePath, df.ResolvedTargetFile, df.FileAttributes); } SolutionFolder c = entry as SolutionFolder; if (c != null) { monitor.BeginTask("Installing solution '" + c.Name + "'", c.Items.Count); foreach (SolutionFolderItem ce in c.Items) { InstallEntry(monitor, ctx, ce, configuration); monitor.Step(1); } monitor.EndTask(); } }
protected override void OnReadProject(ProgressMonitor monitor, MonoDevelop.Projects.MSBuild.MSBuildProject msproject) { base.OnReadProject(monitor, msproject); var ext = msproject.GetMonoDevelopProjectExtension("MonoDevelop.Autotools.MakefileInfo"); if (ext == null) { return; } data = MakefileData.Read(ext); if (data == null) { return; } monitor.BeginTask(GettextCatalog.GetString("Updating project from Makefile"), 1); try { data.OwnerProject = Project; if (data.SupportsIntegration) { data.UpdateProject(monitor, false); } monitor.Step(1); } catch (Exception e) { monitor.ReportError(GettextCatalog.GetString( "\tError loading Makefile for project {0}", Project.Name), e); } finally { monitor.EndTask(); } }
/// <summary> /// Perform push operation between local and remote repository - set remote /// refs appropriately, send needed objects and update local tracking refs. /// <para /> /// When <seealso cref="Transport.DryRun"/> is true, result of this operation is /// just estimation of real operation result, no real action is performed. /// </summary> /// <param name="monitor"> /// Progress monitor used for feedback about operation. /// </param> /// <returns> result of push operation with complete status description. </returns> /// <exception cref="NotSupportedException"> /// When push operation is not supported by provided transport. /// </exception> /// <exception cref="TransportException"> /// When some error occurred during operation, like I/O, protocol /// error, or local database consistency error. /// </exception> public PushResult execute(ProgressMonitor monitor) { monitor.BeginTask(PROGRESS_OPENING_CONNECTION, ProgressMonitor.UNKNOWN); _connection = _transport.openPush(); try { monitor.EndTask(); IDictionary <string, RemoteRefUpdate> preprocessed = PrepareRemoteUpdates(); if (_transport.DryRun) { ModifyUpdatesForDryRun(); } else if (preprocessed.Count != 0) { _connection.Push(monitor, preprocessed); } } finally { _connection.Close(); } if (!_transport.DryRun) { UpdateTrackingRefs(); } return(PrepareOperationResult()); }
internal bool Build(ProgressMonitor monitor) { monitor.BeginTask("Package: " + Description, 1); DeployContext ctx = null; try { ctx = CreateDeployContext(); if (ctx != null) { ctx.FileFilter = this; } if (!OnBuild(monitor, ctx)) { return(false); } } catch (Exception ex) { monitor.ReportError("Package creation failed", ex); LoggingService.LogError("Package creation failed", ex); return(false); } finally { monitor.EndTask(); if (ctx != null) { ctx.Dispose(); } } return(true); }
internal static void Report(ProgressMonitor monitor, List <Diagnostic> allDiagnostics, Projects.WorkspaceObject parent) { monitor.BeginTask(GettextCatalog.GetString("Reporting results..."), allDiagnostics.Count); TaskService.Errors.Clear(); TaskService.Errors.AddRange(allDiagnostics.Select(diagnostic => { var startLinePosition = diagnostic.Location.GetLineSpan().StartLinePosition; return(new TaskListEntry( diagnostic.Location.SourceTree.FilePath, diagnostic.GetMessage(), startLinePosition.Character + 1, startLinePosition.Line + 1, GetSeverity(diagnostic), TaskPriority.Normal, parent, null, diagnostic.Descriptor.Category )); })); monitor.EndTask(); if (!allDiagnostics.Any()) { monitor.ReportSuccess(GettextCatalog.GetString("Analysis successful.")); } else { ShowAnalyzationResults(); } }
private ICollection <WalkRemoteObjectDatabase> ExpandOneAlternate(AnyObjectId id, ProgressMonitor pm) { while (_noAlternatesYet.Count > 0) { WalkRemoteObjectDatabase wrr = _noAlternatesYet.First.Value; _noAlternatesYet.RemoveFirst(); try { pm.BeginTask("Listing alternates", ProgressMonitor.UNKNOWN); ICollection <WalkRemoteObjectDatabase> altList = wrr.getAlternates(); if (altList != null && altList.Count > 0) { return(altList); } } catch (IOException e) { // Try another repository. // RecordError(id, e); } finally { pm.EndTask(); } } return(null); }
/// <summary> /// Checks that the xml in this view is well-formed. /// </summary> public static XmlDocument ValidateWellFormedness(ProgressMonitor monitor, string xml, string fileName) { monitor.BeginTask(GettextCatalog.GetString("Validating XML..."), 1); bool error = false; XmlDocument doc = null; try { doc = new XmlDocument(); doc.LoadXml(xml); } catch (XmlException ex) { monitor.ReportError(ex.Message, ex); AddTask(fileName, ex.Message, ex.LinePosition, ex.LineNumber, TaskSeverity.Error); error = true; } if (error) { monitor.Log.WriteLine(GettextCatalog.GetString("Validation failed.")); TaskService.ShowErrors(); } else { monitor.Log.WriteLine(GettextCatalog.GetString("XML is valid.")); } monitor.EndTask(); return(error? null: doc); }
public async void OnReload() { var solutions = new HashSet <Solution> (); Task task = Task.CompletedTask; using (ProgressMonitor m = IdeApp.Workbench.ProgressMonitors.GetProjectLoadProgressMonitor(true)) { m.BeginTask(null, CurrentNodes.Length); foreach (ITreeNavigator node in CurrentNodes) { UnknownSolutionItem entry = (UnknownSolutionItem)node.DataItem; if (!entry.Enabled) { entry.Enabled = true; solutions.Add(entry.ParentSolution); } var am = m.BeginAsyncStep(1); var t = entry.ParentFolder.ReloadItem(am, entry).ContinueWith(ta => { am.Dispose(); }); task = Task.WhenAll(task, t); } m.EndTask(); } await task; await IdeApp.ProjectOperations.SaveAsync(solutions); }
private void MakeStaticLibrary(Project project, ProjectFileCollection projectFiles, CProjectConfiguration configuration, ProjectPackageCollection packages, CompilerResults cr, ProgressMonitor monitor, string outputName) { if (!NeedsUpdate(projectFiles, configuration, outputName)) { return; } string objectFiles = string.Join(" ", ObjectFiles(projectFiles, configuration, true)); string args = string.Format("rcs \"{0}\" {1}", outputName, objectFiles); monitor.BeginTask(GettextCatalog.GetString("Generating static library {0} from object files", Path.GetFileName(outputName)), 1); string errorOutput; int exitCode = ExecuteCommand("ar", args, Path.GetDirectoryName(outputName), monitor, out errorOutput); if (exitCode == 0) { monitor.Step(1); } monitor.EndTask(); ParseCompilerOutput(errorOutput, cr); ParseLinkerOutput(errorOutput, cr); CheckReturnCode(exitCode, cr); }
private ICollection <WalkRemoteObjectDatabase> ExpandOneAlternate(AnyObjectId id, ProgressMonitor pm) { while (!noAlternatesYet.IsEmpty()) { WalkRemoteObjectDatabase wrr = noAlternatesYet.RemoveFirst(); try { pm.BeginTask(JGitText.Get().listingAlternates, ProgressMonitor.UNKNOWN); ICollection <WalkRemoteObjectDatabase> altList = wrr.GetAlternates(); if (altList != null && !altList.IsEmpty()) { return(altList); } } catch (IOException e) { // Try another repository. // RecordError(id, e); } finally { pm.EndTask(); } } return(null); }
public void Dispose() { monitor?.EndTask(); monitor?.ReportSuccess("Done."); monitor?.Dispose(); monitor = null; }
public async Task <BuildResult> Clean(ProgressMonitor monitor, ConfigurationSelector configuration, OperationContext operationContext = null) { if (ParentSolution == null) { return(new BuildResult()); } SolutionConfiguration conf = ParentSolution.GetConfiguration(configuration); if (conf == null) { return(new BuildResult()); } ReadOnlyCollection <SolutionItem> allProjects; try { allProjects = GetAllBuildableEntries(configuration, true, true); } catch (CyclicDependencyException) { monitor.ReportError(GettextCatalog.GetString("Cyclic dependencies are not supported."), null); return(new BuildResult("", 1, 1)); } monitor.BeginTask(GettextCatalog.GetString("Cleaning Solution: {0} ({1})", Name, configuration.ToString()), allProjects.Count); try { return(await RunParallelBuildOperation(monitor, configuration, allProjects, (ProgressMonitor m, SolutionItem item) => { return item.Clean(m, configuration, operationContext); }, false)); } finally { monitor.EndTask(); } }
protected async override Task OnExecute(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { if (data == null || !data.SupportsIntegration || String.IsNullOrEmpty(data.ExecuteTargetName)) { await base.OnExecute(monitor, context, configuration); 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 async Task <BuildResult> Build(ProgressMonitor monitor, ConfigurationSelector configuration, bool buildReferencedTargets = false, OperationContext operationContext = null) { ReadOnlyCollection <SolutionItem> allProjects; try { allProjects = GetAllBuildableEntries(configuration, true, true); } catch (CyclicDependencyException) { monitor.ReportError(GettextCatalog.GetString("Cyclic dependencies are not supported."), null); return(new BuildResult("", 1, 1)); } if (operationContext == null) { operationContext = new OperationContext(); } bool operationStarted = false; BuildResult result = null; try { monitor.BeginTask(GettextCatalog.GetString("Building Solution: {0} ({1})", Name, configuration.ToString()), allProjects.Count); operationStarted = ParentSolution != null && await ParentSolution.BeginBuildOperation(monitor, configuration, operationContext); return(result = await RunParallelBuildOperation(monitor, configuration, allProjects, (ProgressMonitor m, SolutionItem item) => { return item.Build(m, configuration, false, operationContext); }, false)); } finally { if (operationStarted) { await ParentSolution.EndBuildOperation(monitor, configuration, operationContext, result); } monitor.EndTask(); } }
void RunActionsWithProgressMonitor( ProgressMonitorStatusMessage progressMessage, IList <IPackageAction> installPackageActions, TaskCompletionSource <bool> taskCompletionSource, bool clearConsole, CancellationTokenSource cancellationTokenSource) { using (ProgressMonitor monitor = progressMonitorFactory.CreateProgressMonitor(progressMessage.Status, clearConsole, cancellationTokenSource)) { using (PackageManagementEventsMonitor eventMonitor = CreateEventMonitor(monitor, taskCompletionSource)) { try { monitor.BeginTask(null, installPackageActions.Count); RunActionsWithProgressMonitor(monitor, installPackageActions); eventMonitor.ReportResult(progressMessage); } catch (Exception ex) { RemoveInstallActions(installPackageActions); bool showPackageConsole = !monitor.CancellationToken.IsCancellationRequested; eventMonitor.ReportError(progressMessage, ex, showPackageConsole); } finally { monitor.EndTask(); GuiDispatch(() => { RemoveInstallActions(installPackageActions); packageManagementEvents.OnPackageOperationsFinished(); }); } } } }
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(); }
/// <exception cref="System.IO.IOException"></exception> private void PutImpl(string bucket, string key, byte[] csum, TemporaryBuffer buf, ProgressMonitor monitor, string monitorTask) { if (monitor == null) { monitor = NullProgressMonitor.INSTANCE; } if (monitorTask == null) { monitorTask = MessageFormat.Format(JGitText.Get().progressMonUploading, key); } string md5str = Base64.EncodeBytes(csum); long len = buf.Length(); string lenstr = len.ToString(); for (int curAttempt = 0; curAttempt < maxAttempts; curAttempt++) { HttpURLConnection c = Open("PUT", bucket, key); c.SetRequestProperty("Content-Length", lenstr); c.SetRequestProperty("Content-MD5", md5str); c.SetRequestProperty(X_AMZ_ACL, acl); encryption.Request(c, X_AMZ_META); Authorize(c); c.SetDoOutput(true); c.SetFixedLengthStreamingMode((int)len); monitor.BeginTask(monitorTask, (int)(len / 1024)); OutputStream os = c.GetOutputStream(); try { buf.WriteTo(os, monitor); } finally { monitor.EndTask(); os.Close(); } switch (HttpSupport.Response(c)) { case HttpURLConnection.HTTP_OK: { return; } case HttpURLConnection.HTTP_INTERNAL_ERROR: { continue; goto default; } default: { throw Error("Writing", key, c); } } } throw MaxAttempts("Writing", key); }
public void Wakeup() { try { tracker.EndTask(); tracker.Dispose(); } finally { Finished(); } }
public void Wakeup() { try { tracker.EndTask(); // Remove this when https://github.com/mono/monodevelop/issue/4751 is fixed. Runtime.MainSynchronizationContext.Post(o => ((ProgressMonitor)o).Dispose(), tracker); } finally { Finished(); } }
public async Task SaveAsync (ProgressMonitor monitor) { monitor.BeginTask (GettextCatalog.GetString ("Saving Workspace..."), Items.Count); List<WorkspaceItem> items = new List<WorkspaceItem> (Items); foreach (WorkspaceItem it in items) { await it.SaveAsync (monitor); monitor.Step (1); } monitor.EndTask (); }
void WriteProjects(SolutionFolder folder, SlnFile sln, ProgressMonitor monitor, HashSet <string> unknownProjects) { monitor.BeginTask(folder.Items.Count); foreach (SolutionFolderItem ce in folder.Items.ToArray()) { monitor.BeginStep(); if (ce is SolutionItem) { SolutionItem item = (SolutionItem)ce; var proj = sln.Projects.GetOrCreateProject(ce.ItemId); proj.TypeGuid = item.TypeGuid; proj.Name = item.Name; proj.FilePath = FileService.NormalizeRelativePath(FileService.AbsoluteToRelativePath(sln.BaseDirectory, item.FileName)).Replace('/', '\\'); var sec = proj.Sections.GetOrCreateSection("MonoDevelopProperties", SlnSectionType.PreProcess); sec.SkipIfEmpty = true; folder.ParentSolution.WriteSolutionFolderItemData(monitor, sec.Properties, ce); if (item.ItemDependencies.Count > 0) { sec = proj.Sections.GetOrCreateSection("ProjectDependencies", SlnSectionType.PostProcess); sec.Properties.ClearExcept(unknownProjects); foreach (var dep in item.ItemDependencies) { sec.Properties.SetValue(dep.ItemId, dep.ItemId); } } else { proj.Sections.RemoveSection("ProjectDependencies"); } } else if (ce is SolutionFolder) { var proj = sln.Projects.GetOrCreateProject(ce.ItemId); proj.TypeGuid = MSBuildProjectService.FolderTypeGuid; proj.Name = ce.Name; proj.FilePath = ce.Name; // Folder files WriteFolderFiles(proj, (SolutionFolder)ce); //Write custom properties var sec = proj.Sections.GetOrCreateSection("MonoDevelopProperties", SlnSectionType.PreProcess); sec.SkipIfEmpty = true; folder.ParentSolution.WriteSolutionFolderItemData(monitor, sec.Properties, ce); } if (ce is SolutionFolder) { WriteProjects(ce as SolutionFolder, sln, monitor, unknownProjects); } } monitor.EndTask(); }
/// <summary> /// Validates the schema. /// </summary> public static XmlSchema ValidateSchema(ProgressMonitor monitor, string xml, string fileName) { monitor.BeginTask(GettextCatalog.GetString("Validating schema..."), 1); bool error = false; XmlSchema schema = null; try { StringReader stringReader = new StringReader(xml); XmlTextReader xmlReader = new XmlTextReader(stringReader); xmlReader.XmlResolver = null; ValidationEventHandler callback = delegate(object source, ValidationEventArgs args) { if (args.Severity == XmlSeverityType.Warning) { monitor.ReportWarning(args.Message); } else { monitor.ReportError(args.Message, args.Exception); error = true; } AddTask(fileName, args.Message, args.Exception.LinePosition, args.Exception.LineNumber, (args.Severity == XmlSeverityType.Warning)? TaskSeverity.Warning : TaskSeverity.Error); }; schema = XmlSchema.Read(xmlReader, callback); XmlSchemaSet sset = new XmlSchemaSet(); sset.Add(schema); sset.ValidationEventHandler += callback; sset.Compile(); } catch (XmlSchemaException ex) { monitor.ReportError(ex.Message, ex); AddTask(fileName, ex.Message, ex.LinePosition, ex.LineNumber, TaskSeverity.Error); error = true; } catch (XmlException ex) { monitor.ReportError(ex.Message, ex); AddTask(fileName, ex.Message, ex.LinePosition, ex.LineNumber, TaskSeverity.Error); error = true; } if (error) { monitor.Log.WriteLine(GettextCatalog.GetString("Validation failed.")); TaskService.ShowErrors(); } else { monitor.Log.WriteLine(GettextCatalog.GetString("Schema is valid.")); } monitor.EndTask(); return(error? null: schema); }
public void OnReload() { using (ProgressMonitor m = IdeApp.Workbench.ProgressMonitors.GetProjectLoadProgressMonitor(true)) { m.BeginTask(null, CurrentNodes.Length); foreach (ITreeNavigator node in CurrentNodes) { Solution solution = (Solution)node.DataItem; solution.ParentWorkspace.ReloadItem(m, solution); m.Step(1); } m.EndTask(); } }
public void OnReload() { using (ProgressMonitor m = IdeApp.Workbench.ProgressMonitors.GetProjectLoadProgressMonitor(true)) { m.BeginTask(null, CurrentNodes.Length); foreach (ITreeNavigator nav in CurrentNodes) { Project p = (Project)nav.DataItem; p.ParentFolder.ReloadItem(m, p); m.Step(1); } m.EndTask(); } }
//Reader public async Task <object> ReadFile(string fileName, ProgressMonitor monitor) { if (fileName == null || monitor == null) { return(null); } var sol = new Solution(true); sol.FileName = fileName; sol.FileFormat = format; try { monitor.BeginTask(string.Format(GettextCatalog.GetString("Loading solution: {0}"), fileName), 1); monitor.BeginStep(); await sol.OnBeginLoad(); var projectLoadMonitor = monitor as ProjectLoadProgressMonitor; if (projectLoadMonitor != null) { projectLoadMonitor.CurrentSolution = sol; } await Task.Factory.StartNew(() => { sol.ReadSolution(monitor); }); } catch (Exception ex) { monitor.ReportError(GettextCatalog.GetString("Could not load solution: {0}", fileName), ex); await sol.OnEndLoad(); sol.NotifyItemReady(); monitor.EndTask(); throw; } await sol.OnEndLoad(); sol.NotifyItemReady(); monitor.EndTask(); return(sol); }
internal async Task Initialize(ProgressMonitor monitor) { monitor.BeginTask(GettextCatalog.GetString("Initializing Main Window"), 4); try { monitors = (IdeProgressMonitorManager)await Runtime.GetService <ProgressMonitorManager> (); documentManager = await Runtime.GetService <DocumentManager> (); await Runtime.GetService <DocumentModelRegistry> (); await Runtime.GetService <DocumentControllerService> (); Counters.Initialization.Trace("Creating DefaultWorkbench"); workbench = (DefaultWorkbench)await Runtime.GetService <IShell> (); monitor.Step(1); Counters.Initialization.Trace("Initializing Workspace"); workbench.InitializeWorkspace(); monitor.Step(1); Counters.Initialization.Trace("Initializing Layout"); workbench.InitializeLayout(); monitor.Step(1); ((Gtk.Window)workbench).Visible = false; workbench.WorkbenchTabsChanged += WorkbenchTabsChanged; IdeApp.Workspace.StoringUserPreferences += OnStoringWorkspaceUserPreferences; IdeApp.Workspace.LoadingUserPreferences += OnLoadingWorkspaceUserPreferences; IdeApp.FocusOut += delegate(object o, EventArgs args) { if (!fileEventsFrozen) { fileEventsFrozen = true; FileService.FreezeEvents(); } }; IdeApp.FocusIn += delegate(object o, EventArgs args) { if (fileEventsFrozen) { fileEventsFrozen = false; FileService.ThawEvents(); } }; pads = null; // Make sure we get an up to date pad list. monitor.Step(1); } finally { monitor.EndTask(); } }
async Task WriteWorkspaceItem(FilePath actualFile, FilePath outFile, WorkspaceItem item, ProgressMonitor monitor) { Workspace ws = item as Workspace; if (ws != null) { monitor.BeginTask(null, ws.Items.Count); try { foreach (WorkspaceItem it in ws.Items) { await it.SaveAsync(monitor); monitor.Step(1); } } finally { monitor.EndTask(); } } await Task.Run(delegate { StreamWriter sw = new StreamWriter(outFile); try { monitor.BeginTask(GettextCatalog.GetString("Saving item: {0}", actualFile), 1); XmlTextWriter tw = new XmlTextWriter(sw); tw.Formatting = Formatting.Indented; XmlDataSerializer ser = new XmlDataSerializer(MD1ProjectService.DataContext); ser.SerializationContext.BaseFile = actualFile; ser.SerializationContext.ProgressMonitor = monitor; ser.Serialize(sw, item, typeof(WorkspaceItem)); } catch (Exception ex) { monitor.ReportError(GettextCatalog.GetString("Could not save item: {0}", actualFile), ex); throw; } finally { monitor.EndTask(); sw.Close(); } }); }
/// <exception cref="System.IO.IOException"></exception> internal virtual void Compute(ProgressMonitor pm) { if (pm == null) { pm = NullProgressMonitor.INSTANCE; } pm.BeginTask(JGitText.Get().renamesFindingByContent, 2 * srcs.Count * dsts.Count); // int mNext = BuildMatrix(pm); @out = new AList <DiffEntry>(Math.Min(mNext, dsts.Count)); // Match rename pairs on a first come, first serve basis until // we have looked at everything that is above our minimum score. // for (--mNext; mNext >= 0; mNext--) { long ent = matrix[mNext]; int sIdx = SrcFile(ent); int dIdx = DstFile(ent); DiffEntry s = srcs[sIdx]; DiffEntry d = dsts[dIdx]; if (d == null) { pm.Update(1); continue; } // was already matched earlier DiffEntry.ChangeType type; if (s.changeType == DiffEntry.ChangeType.DELETE) { // First use of this source file. Tag it as a rename so we // later know it is already been used as a rename, other // matches (if any) will claim themselves as copies instead. // s.changeType = DiffEntry.ChangeType.RENAME; type = DiffEntry.ChangeType.RENAME; } else { type = DiffEntry.ChangeType.COPY; } @out.AddItem(DiffEntry.Pair(type, s, d, Score(ent))); dsts.Set(dIdx, null); // Claim the destination was matched. pm.Update(1); } srcs = CompactSrcList(srcs); dsts = CompactDstList(dsts); pm.EndTask(); }
public PushResult execute(ProgressMonitor monitor) { monitor.BeginTask(PROGRESS_OPENING_CONNECTION, -1); connection = transport.openPush(); try { monitor.EndTask(); Dictionary<string, RemoteRefUpdate> preprocessed = prepareRemoteUpdates(); if (transport.DryRun) modifyUpdatesForDryRun(); else if (preprocessed.Count != 0) connection.Push(monitor, preprocessed); } finally { connection.Close(); } if (!transport.DryRun) updateTrackingRefs(); return prepareOperationResult(); }
private void DownloadObject(ProgressMonitor pm, AnyObjectId id) { if (_local.HasObject(id)) return; while (true) { if (DownloadPackedObject(pm, id)) return; string idStr = id.Name; string subdir = idStr.Slice(0, 2); string file = idStr.Substring(2); string looseName = subdir + "/" + file; for (int i = _lastRemoteIdx; i < _remotes.Count; i++) { if (DownloadLooseObject(id, looseName, _remotes[i])) { _lastRemoteIdx = i; return; } } for (int i = 0; i < _lastRemoteIdx; i++) { if (DownloadLooseObject(id, looseName, _remotes[i])) { _lastRemoteIdx = i; return; } } while (_noPacksYet.Count > 0) { WalkRemoteObjectDatabase wrr = _noPacksYet.First.Value; _noPacksYet.RemoveFirst(); List<string> packNameList; try { pm.BeginTask("Listing packs", ProgressMonitor.UNKNOWN); packNameList = wrr.getPackNames(); } catch (IOException e) { RecordError(id, e); continue; } finally { pm.EndTask(); } if (packNameList == null || packNameList.Count == 0) continue; foreach (string packName in packNameList) { if (!_packsConsidered.Contains(packName)) { _packsConsidered.Add(packName); _unfetchedPacks.AddLast(new RemotePack(_lockMessage, _packLocks, _objCheck, _local, wrr, packName)); } } if (DownloadPackedObject(pm, id)) return; } List<WalkRemoteObjectDatabase> al = ExpandOneAlternate(id, pm); if (al != null && al.Count > 0) { foreach (WalkRemoteObjectDatabase alt in al) { _remotes.Add(alt); _noPacksYet.AddLast(alt); _noAlternatesYet.AddLast(alt); } continue; } List<Exception> failures = null; if (_fetchErrors.ContainsKey(id.Copy())) { failures = _fetchErrors[id.Copy()]; } TransportException te = null; if (failures != null && failures.Count > 0) { te = failures.Count == 1 ? new TransportException("Cannot get " + id.Name + ".", failures[0]) : new TransportException("Cannot get " + id.Name + ".", new CompoundException(failures)); } if (te == null) { te = new TransportException("Cannot get " + id.Name + "."); } throw te; } }
/// <summary> /// Perform push operation between local and remote repository - set remote /// refs appropriately, send needed objects and update local tracking refs. /// <para /> /// When <seealso cref="Transport.DryRun"/> is true, result of this operation is /// just estimation of real operation result, no real action is performed. /// </summary> /// <param name="monitor"> /// Progress monitor used for feedback about operation. /// </param> /// <returns> result of push operation with complete status description. </returns> /// <exception cref="NotSupportedException"> /// When push operation is not supported by provided transport. /// </exception> /// <exception cref="TransportException"> /// When some error occurred during operation, like I/O, protocol /// error, or local database consistency error. /// </exception> public PushResult execute(ProgressMonitor monitor) { if (monitor == null) throw new ArgumentNullException("monitor"); monitor.BeginTask(PROGRESS_OPENING_CONNECTION, ProgressMonitor.UNKNOWN); _connection = _transport.openPush(); try { monitor.EndTask(); IDictionary<string, RemoteRefUpdate> preprocessed = PrepareRemoteUpdates(); if (_transport.DryRun) { ModifyUpdatesForDryRun(); } else if (preprocessed.Count != 0) { _connection.Push(monitor, preprocessed); } } finally { _connection.Close(); } if (!_transport.DryRun) { UpdateTrackingRefs(); } return PrepareOperationResult(); }
private void DownloadObject(ProgressMonitor pm, AnyObjectId id) { if (_local.HasObject(id)) return; while (true) { // Try a pack file we know about, but don't have yet. Odds are // that if it has this object, it has others related to it so // getting the pack is a good bet. // if (DownloadPackedObject(pm, id)) return; // Search for a loose object over all alternates, starting // from the one we last successfully located an object through. // string idStr = id.Name; string subdir = idStr.Slice(0, 2); string file = idStr.Substring(2); string looseName = subdir + "/" + file; for (int i = _lastRemoteIdx; i < _remotes.Count; i++) { if (DownloadLooseObject(id, looseName, _remotes[i])) { _lastRemoteIdx = i; return; } } for (int i = 0; i < _lastRemoteIdx; i++) { if (DownloadLooseObject(id, looseName, _remotes[i])) { _lastRemoteIdx = i; return; } } // Try to obtain more pack information and search those. // while (_noPacksYet.Count > 0) { WalkRemoteObjectDatabase wrr = _noPacksYet.First.Value; _noPacksYet.RemoveFirst(); ICollection<string> packNameList; try { pm.BeginTask("Listing packs", ProgressMonitor.UNKNOWN); packNameList = wrr.getPackNames(); } catch (IOException e) { // Try another repository. // RecordError(id, e); continue; } finally { pm.EndTask(); } if (packNameList == null || packNameList.Count == 0) continue; foreach (string packName in packNameList) { bool contains = _packsConsidered.Contains(packName); _packsConsidered.Add(packName); if (!contains) { _unfetchedPacks.AddLast(new RemotePack(_lockMessage, _packLocks, _objCheck, _local, wrr, packName)); } } if (DownloadPackedObject(pm, id)) return; } // Try to expand the first alternate we haven't expanded yet. // ICollection<WalkRemoteObjectDatabase> al = ExpandOneAlternate(id, pm); if (al != null && al.Count > 0) { foreach (WalkRemoteObjectDatabase alt in al) { _remotes.Add(alt); _noPacksYet.AddLast(alt); _noAlternatesYet.AddLast(alt); } continue; } // We could not obtain the object. There may be reasons why. // List<Exception> failures = _fetchErrors.get(id.Copy()); var te = new TransportException("Cannot get " + id.Name + "."); if (failures != null && failures.Count > 0) { te = failures.Count == 1 ? new TransportException("Cannot get " + id.Name + ".", failures[0]) : new TransportException("Cannot get " + id.Name + ".", new CompoundException(failures)); } throw te; } }
public void OpenIndex(ProgressMonitor pm) { if (Index != null) return; try { Index = PackIndex.Open(TmpIdx); return; } catch (FileNotFoundException) { } Stream s = _connection.open("pack/" + _idxName); pm.BeginTask("Get " + _idxName.Slice(0, 12) + "..idx", s.Length < 0 ? -1 : (int)(s.Length / 1024)); try { var fos = new FileStream(TmpIdx.ToString(), System.IO.FileMode.Open, FileAccess.ReadWrite); try { var buf = new byte[2048]; int cnt; while (!pm.IsCancelled && (cnt = s.Read(buf, 0, buf.Length)) >= 0) { fos.Write(buf, 0, cnt); pm.Update(cnt / 1024); } } finally { fos.Close(); } } catch (IOException) { TmpIdx.Delete(); throw; } finally { s.Close(); } pm.EndTask(); if (pm.IsCancelled) { TmpIdx.Delete(); return; } try { Index = PackIndex.Open(TmpIdx); } catch (IOException) { TmpIdx.Delete(); throw; } }
private List<WalkRemoteObjectDatabase> ExpandOneAlternate(AnyObjectId id, ProgressMonitor pm) { while (_noAlternatesYet.Count > 0) { WalkRemoteObjectDatabase wrr = _noAlternatesYet.First.Value; _noAlternatesYet.RemoveFirst(); try { pm.BeginTask("Listing alternates", ProgressMonitor.UNKNOWN); List<WalkRemoteObjectDatabase> altList = wrr.getAlternates(); if (altList != null && altList.Count > 0) return altList; } catch (IOException e) { RecordError(id, e); } finally { pm.EndTask(); } } return null; }
public void OpenIndex(ProgressMonitor pm) { if (Index != null) return; if (TmpIdx.IsFile()) { try { Index = PackIndex.Open(TmpIdx); return; } catch (FileNotFoundException) { // Fall through and get the file. } } using (Stream s = _connection.open("pack/" + _idxName)) { pm.BeginTask("Get " + _idxName.Slice(0, 12) + "..idx", !s.CanSeek ? ProgressMonitor.UNKNOWN : (int)(s.Length / 1024)); try { using (var fos = new FileStream(TmpIdx.FullName, System.IO.FileMode.CreateNew, FileAccess.Write)) { var buf = new byte[2048]; int cnt; while (!pm.IsCancelled && (cnt = s.Read(buf, 0, buf.Length)) > 0) { fos.Write(buf, 0, cnt); pm.Update(cnt / 1024); } } } catch (IOException) { TmpIdx.DeleteFile(); throw; } } pm.EndTask(); if (pm.IsCancelled) { TmpIdx.DeleteFile(); return; } try { Index = PackIndex.Open(TmpIdx); } catch (IOException) { TmpIdx.DeleteFile(); throw; } }
private void ResolveDeltas(ProgressMonitor progress) { progress.BeginTask(PROGRESS_RESOLVE_DELTA, _deltaCount); int last = _entryCount; for (int i = 0; i < last; i++) { int before = _entryCount; ResolveDeltas(_entries[i]); progress.Update(_entryCount - before); if (progress.IsCancelled) { throw new IOException("Download cancelled during indexing"); } } progress.EndTask(); }
public void index(ProgressMonitor progress) { progress.Start(2 /* tasks */); try { try { ReadPackHeader(); _entries = new PackedObjectInfo[(int)_objectCount]; _baseById = new ObjectIdSubclassMap<DeltaChain>(); _baseByPos = new LongMap<UnresolvedDelta>(); progress.BeginTask(PROGRESS_DOWNLOAD, (int)_objectCount); for (int done = 0; done < _objectCount; done++) { IndexOneObject(); progress.Update(1); if (progress.IsCancelled) { throw new IOException("Download cancelled"); } } ReadPackFooter(); EndInput(); progress.EndTask(); if (_deltaCount > 0) { if (_packOut == null) { throw new IOException("need packOut"); } ResolveDeltas(progress); if (_entryCount < _objectCount) { if (!_fixThin) { throw new IOException("pack has " + (_objectCount - _entryCount) + " unresolved deltas"); } FixThinPack(progress); } } if (_packOut != null && (_keepEmpty || _entryCount > 0)) { _packOut.Flush(); } _packDigest = null; _baseById = null; _baseByPos = null; if (_dstIdx != null && (_keepEmpty || _entryCount > 0)) { WriteIdx(); } } finally { try { InflaterCache.Instance.release(_inflater); } finally { _inflater = null; } _windowCursor = WindowCursor.Release(_windowCursor); progress.EndTask(); if (_packOut != null) { _packOut.Close(); } } if (_keepEmpty || _entryCount > 0) { if (_dstPack != null) { _dstPack.IsReadOnly = true; } if (_dstIdx != null) { _dstIdx.IsReadOnly = true; } } } catch (IOException) { if (_dstPack != null) _dstPack.Delete(); if (_dstIdx != null) _dstIdx.Delete(); throw; } }