public void loadFiles(List <String> lFilesToLoad, O2Thread.FuncVoidT1 <int> onPartialLoad) { int iFilesProcessed = 0; foreach (String sFileToLoad in lFilesToLoad) { loadFile(sFileToLoad); if (iFilesProcessed++ % 100 == 0) { DI.log.info("Processed files: {0} /{1}", iFilesProcessed, lFilesToLoad.Count); if (onPartialLoad != null) { onPartialLoad(iFilesProcessed); } } } // some file stats DI.log.debug("Number of Files Currently Loaded: {0}", dLoadedFilesCache.Keys.Count); int iLinesOfCode = 0; //int iChars = 0; foreach (var lsLines in dLoadedFilesCache.Values) { iLinesOfCode += lsLines.Count; } DI.log.debug("Number of Lines of Code Currently Loaded: {0}", iLinesOfCode); }
public static List <IXRule> loadXRules(List <string> xRulesAssemblies, O2Thread.FuncVoidT1 <string> currentTask, O2Thread.FuncVoidT1 <int> numberOfStepsToPerform, O2Thread.FuncVoid onStepEvent) { if (currentTask != null) { currentTask("Loading XRules"); } var xRules = new List <IXRule>(); foreach (var xRuleAssembly in xRulesAssemblies) { var assembly = PublicDI.reflection.getAssembly(xRuleAssembly); if (assembly != null) { xRules.AddRange(createXRulesFromAssembly(assembly)); } if (onStepEvent != null) { onStepEvent(); } } if (currentTask != null) { currentTask("XRules Loading Complete"); } return(xRules); }
// O2.Debugger.Mdbg.OriginalMdbgCode.mdbg.mdbgCommandsCustomizedForO2 // , O2Thread.FuncVoid<string> o2Callback) public static bool AttachCmd(string arguments, O2Thread.FuncVoidT1 <string> o2Callback) { try { var ap = new ArgParser(arguments); if (ap.Count > 1) { DI.log.error("in AttachCmd: Wrong # of arguments."); return(false); } if (!ap.Exists(0)) { DI.log.error("in AttachCmd: Please choose some process to attach"); MdbgCommands.ProcessEnumCmd(""); return(false); } int pid = ap.AsInt(0); if (Process.GetCurrentProcess().Id == pid) { DI.log.error("in AttachCmd: Cannot attach to myself!"); return(false); } MDbgProcess p = CommandBase.Debugger.Attach(pid); p.Go().WaitOne(); return(true); } catch (Exception ex) { DI.log.ex(ex, "in AttachCmd"); return(false); } }
public static List <String> getCompiledXRulesAssemblies(O2Thread.FuncVoidT1 <string> currentTask, O2Thread.FuncVoidT1 <int> numberOfStepsToPerform, O2Thread.FuncVoid onStepEvent) { currentTask("Compiling all rules together"); numberOfStepsToPerform(1); // first try to scan all together var filesToCompile = Files.getFilesFromDir_returnFullPath(XRules_Config.PathTo_XRulesDatabase_fromO2, "*.cs", true); // recursive search foreach (var xRuleFile in Files.getFilesFromDir_returnFullPath(XRules_Config.PathTo_XRulesDatabase_fromLocalDisk, "*.cs", true)) // recursive search { if (false == filesToCompile.Contains(xRuleFile)) { filesToCompile.Add(xRuleFile); } } PublicDI.log.info("There are {0} XRules to Compile", filesToCompile.Count); var compiledXRulesAssembly = compileAllFilesTogether(filesToCompile); onStepEvent(); if (compiledXRulesAssembly != null) { return new List <String> { compiledXRulesAssembly.Location } } ; // if we couldn't compile all at once, then compile each file individually PublicDI.log.error("It was not possible to compile all XRules together, going to try to compile each XRule file individually"); //return compileAllFilesIndividually(filesToCompile,currentTask,numberOfStepsToPerform,onStepEvent); return(null); }
public static void ListBreakpoints(O2Thread.FuncVoidT1 <string> o2Callback) { if (CommandBase.Debugger.Processes.HaveActive) { MDbgBreakpointCollection breakpoints = CommandBase.Debugger.Processes.Active.Breakpoints; if (o2Callback != null) { CommandBase.WriteOutput("Current breakpoints:"); } bool haveBps = false; foreach (MDbgBreakpoint b in breakpoints) { if (o2Callback != null) { o2Callback(b.ToString()); } else { CommandBase.WriteOutput(b.ToString()); } haveBps = true; } if (!haveBps) { if (o2Callback != null) { DI.log.debug("There are no breakpoints set in the current active process"); } else { CommandBase.WriteOutput("No breakpoints!"); } } } }
public static List <IXRule> compileXRules(O2Thread.FuncVoidT1 <string> currentTask, O2Thread.FuncVoidT1 <int> numberOfStepsToPerform, O2Thread.FuncVoid onStepEvent) { var compiledXRulesFiles = getCompiledXRulesAssemblies(currentTask, numberOfStepsToPerform, onStepEvent); currentTask("Moving XRules and its dependencies"); numberOfStepsToPerform(compiledXRulesFiles.Count * 2); //var pathToAppDomainWithXRulesAssemblies = populateDirectoryWithAllDependencies(compiledXRulesFiles, onStepEvent); // dont add the dependencies since they are creating a prob with the cmd line tool Files.deleteAllFilesFromDir(XRules_Config.PathTo_XRulesCompiledDlls); foreach (var file in compiledXRulesFiles) { Files.Copy(file, XRules_Config.PathTo_XRulesCompiledDlls); } var pathToAppDomainWithXRulesAssemblies = XRules_Config.PathTo_XRulesCompiledDlls; // special case where we don't need the O2_XRules_Database.dll file in the )CompiledDlls folder // var xRulesDatabaseOriginalDll = System.IO.Path.Combine(pathToAppDomainWithXRulesAssemblies, "O2_XRules_Database.dll"); // if (System.IO.File.Exists(xRulesDatabaseOriginalDll)) // System.IO.File.Delete(xRulesDatabaseOriginalDll); var xRulesAssemblies = new List <string>(); foreach (var originalDll in compiledXRulesFiles) { var dllInXRulesCompiledDllFolder = originalDll.Replace(System.IO.Path.GetDirectoryName(originalDll), pathToAppDomainWithXRulesAssemblies); xRulesAssemblies.Add(dllInXRulesCompiledDllFolder); } return(loadXRules(xRulesAssemblies, currentTask, numberOfStepsToPerform, onStepEvent)); }
public static void compileXRules(O2Thread.FuncVoidT1 <List <IXRule> > onCompilation, O2Thread.FuncVoidT1 <string> currentTask, O2Thread.FuncVoidT1 <int> numberOfStepsToPerform, O2Thread.FuncVoid onStepEvent) { O2Thread.mtaThread( () => { var xRules = compileXRules(currentTask, numberOfStepsToPerform, onStepEvent); onCompilation(xRules); }); }
public static void ShowCmd(string arguments, O2Thread.FuncVoidT1 <string> o2Callback) { MDbgSourcePosition pos = CommandBase.Debugger.Processes.Active.Threads.Active.CurrentSourcePosition; if (pos == null) { throw new MDbgShellException("No source location"); } string fileLoc = CommandBase.Shell.FileLocator.GetFileLocation(pos.Path); if (fileLoc == null) { throw new MDbgShellException(String.Format(CultureInfo.InvariantCulture, "Source file '{0}' not available.", pos.Path)); } IMDbgSourceFile file = CommandBase.Shell.SourceFileMgr.GetSourceFile(fileLoc); var ap = new ArgParser(arguments); if (ap.Count > 1) { throw new MDbgShellException("Wrong # of arguments."); } int around; if (ap.Exists(0)) { around = ap.AsInt(0); } else { around = 3; } int lo, hi; lo = pos.Line - around; if (lo < 1) { lo = 1; } hi = pos.Line + around; if (hi > file.Count) { hi = file.Count; } for (int i = lo; i < hi; i++) { CommandBase.WriteOutput(String.Format(CultureInfo.InvariantCulture, "{0}{1}{2}", i, i == pos.Line ? ":*" : " ", file[i])); } }
public static void WhereCmd(string arguments, O2Thread.FuncVoidT1 <string> o2Callback) { const int default_depth = 100; // default number of frames to print const string countOpt = "c"; const string verboseOpt = "v"; var ap = new ArgParser(arguments, countOpt + ":1;" + verboseOpt); int depth = default_depth; if (ap.OptionPassed(countOpt)) { ArgToken countArg = ap.GetOption(countOpt); if (countArg.AsString == "all") { depth = 0; // 0 means print entire stack0 } else { depth = countArg.AsInt; if (depth <= 0) { throw new MDbgShellException("Depth must be positive number or string \"all\""); } } } if (ap.Count != 0 && ap.Count != 1) { throw new MDbgShellException("Wrong # of arguments."); } if (ap.Count == 0) { // print current thread only InternalWhereCommand(CommandBase.Debugger.Processes.Active.Threads.Active, depth, ap.OptionPassed(verboseOpt)); } else if (ap.AsString(0).Equals("all")) { foreach (MDbgThread t in CommandBase.Debugger.Processes.Active.Threads) { InternalWhereCommand(t, depth, ap.OptionPassed(verboseOpt)); } } else { MDbgThread t = CommandBase.Debugger.Processes.Active.Threads[ap.AsInt(0)]; if (t == null) { throw new MDbgShellException("Wrong thread number"); } else { InternalWhereCommand(t, depth, ap.OptionPassed(verboseOpt)); } } }
public static List <IXRule> getCompiledXRules(O2Thread.FuncVoidT1 <string> currentTask, O2Thread.FuncVoidT1 <int> numberOfStepsToPerform, O2Thread.FuncVoid onStepEvent) { if (XRules_Config.xRulesDatabase != null) { var xRulesAssemblies = Files.getFilesFromDir_returnFullPath(XRules_Config.PathTo_XRulesCompiledDlls, "*.dll"); xRulesAssemblies.AddRange(Files.getFilesFromDir_returnFullPath(XRules_Config.PathTo_XRulesCompiledDlls, "*.exe")); return(loadXRules(xRulesAssemblies, currentTask, numberOfStepsToPerform, onStepEvent)); } return(new List <IXRule>()); }
public void EditRules(List <IO2Rule> o2RulesToEdit, O2Thread.FuncVoidT1 <IO2Rule> _onSave) { this.invokeOnThread( () => { onSave = _onSave; newRule(); laDataSaved.Visible = false; btSaveRuleChanges.Enabled = false; btSaveChangesToAllRules.Enabled = true; laNumberOfRulesLoaded.Text = o2RulesToEdit.Count + " rule loaded"; o2LoadedRules = o2RulesToEdit; o2LoadedRule = null; }); }
public void editRule(IO2Rule ruleToEdit, O2Thread.FuncVoidT1<IO2Rule> _onSave) { this.invokeOnThread( () => { laDataSaved.Visible = false; btSaveRuleChanges.Enabled = true; btSaveChangesToAllRules.Enabled = false; laUnsavedChanges.Visible = false; laNumberOfRulesLoaded.Text = "1 rule loaded"; onSave = _onSave; o2LoadedRule = ruleToEdit; loadRuleIntoEditor(o2LoadedRule); o2LoadedRules.Clear(); o2LoadedRules.Add(o2LoadedRule); }); }
public void editRule(IO2Rule ruleToEdit, O2Thread.FuncVoidT1 <IO2Rule> _onSave) { this.invokeOnThread( () => { laDataSaved.Visible = false; btSaveRuleChanges.Enabled = true; btSaveChangesToAllRules.Enabled = false; laUnsavedChanges.Visible = false; laNumberOfRulesLoaded.Text = "1 rule loaded"; onSave = _onSave; o2LoadedRule = ruleToEdit; loadRuleIntoEditor(o2LoadedRule); o2LoadedRules.Clear(); o2LoadedRules.Add(o2LoadedRule); }); }
public static void BreakCmd(string arguments, O2Thread.FuncVoidT1 <string> o2Callback) { if (arguments.Length == 0) { ListBreakpoints(o2Callback); return; } // We're adding a breakpoint. Parse the argument string. MDbgBreakpointCollection breakpoints = CommandBase.Debugger.Processes.Active.Breakpoints; ISequencePointResolver bploc = CommandBase.Shell.BreakpointParser.ParseFunctionBreakpoint(arguments); if (bploc == null) { throw new MDbgShellException("Invalid breakpoint syntax."); } MDbgBreakpoint bpnew = CommandBase.Debugger.Processes.Active.Breakpoints.CreateBreakpoint(bploc); CommandBase.WriteOutput(bpnew.ToString()); }
public static void ProcessEnumCmd(string arguments, O2Thread.FuncVoidT1 <CorPublishProcess> handleManagedProcess) // extended with Lambda method { var cp = new CorPublish(); CommandBase.WriteOutput("Active processes on current machine:"); foreach (CorPublishProcess cpp in cp.EnumProcesses()) { if (Process.GetCurrentProcess().Id == cpp.ProcessId) // let's hide our process { continue; } // Try and get the list of AppDomains, but watch for the process terminating IEnumerable appDomainEnum; try { appDomainEnum = cpp.EnumAppDomains(); } catch (COMException e) { if ((uint)e.ErrorCode == 0x80131301) //CORDBG_E_PROCESS_TERMINATED { continue; // process was terminated, ignore it } throw; // let error propogate up } if (handleManagedProcess != null) { handleManagedProcess(cpp); } else { CommandBase.WriteOutput("(PID: " + cpp.ProcessId + ") " + cpp.DisplayName); foreach (CorPublishAppDomain cpad in appDomainEnum) { CommandBase.WriteOutput("\t(ID: " + cpad.Id + ") " + cpad.Name); } } } }
public static void createAssessessmentFileWithJoinnedTraces( string textFilter, Dictionary <string, O2TraceBlock_OunceV6> _dRawData, ICirData _cdCirData, Dictionary <string, O2TraceBlock_OunceV6> _dO2TraceBlock, bool bOnlyProcessTracesWithNoCallers, string targetFolder, string fileNamePrefix, bool bCreateFileWithAllTraces, bool bCreateFileWithUniqueTraces, bool bDropDuplicateSmartTraces, bool bIgnoreRootCallInvocation, O2Thread.FuncVoidT1 <List <TreeNode> > viewNormalizedTraces, Func <string, string> onCompletion) { O2Thread.mtaThread( () => { DI.log.debug("\n\n\ncreateAssessessmentFileWithJoinnedTraces: step 1 - createListOfNormalizedTraces\n\n\n"); var ltnNormalizedTraces = createListOfNormalizedTraces(textFilter, _dRawData, _cdCirData, _dO2TraceBlock, bOnlyProcessTracesWithNoCallers); if (ltnNormalizedTraces.Count == 0) { DI.log.error("There were no normalized traces, aborting"); onCompletion(""); return; } if (viewNormalizedTraces != null) { viewNormalizedTraces(ltnNormalizedTraces); } DI.log.debug("\n\n\ncreateAssessessmentFileWithJoinnedTraces: step 2 - createSavedAssessmentSearchObjectFromNormalizedTraces\n\n\n"); var sasSavedAssessmentSearch = createSavedAssessmentSearchObjectFromNormalizedTraces(ltnNormalizedTraces); DI.log.debug("\n\n\ncreateAssessessmentFileWithJoinnedTraces: step 3 - createAssessmentFileFromSavedAssessmentSearchObject\n\n\n"); var sAssessmentFile = createAssessmentFileFromSavedAssessmentSearchObject( sasSavedAssessmentSearch, targetFolder, fileNamePrefix, bCreateFileWithAllTraces, bCreateFileWithUniqueTraces, bDropDuplicateSmartTraces, bIgnoreRootCallInvocation); DI.log.debug("\n\n\ncreateAssessessmentFileWithJoinnedTraces: completed\n\n\n"); onCompletion(sAssessmentFile); }); }
public static void DeleteCmd(string arguments, O2Thread.FuncVoidT1 <string> o2Callback) { var ap = new ArgParser(arguments); if (ap.Count != 1) { CommandBase.WriteOutput("Please choose some breakpoint to delete"); MdbgCommands.BreakCmd(""); return; } MDbgBreakpoint breakpoint = CommandBase.Debugger.Processes.Active.Breakpoints[ap.AsInt(0)]; if (breakpoint == null) { throw new MDbgShellException("Could not find breakpint #:" + ap.AsInt(0)); } else { breakpoint.Delete(); } }
public static void FuncEvalCmd(string arguments, IMDbgShell Shell, O2Thread.FuncVoidT1 <string> execOnEval) { try { var activeProcess = DI.o2MDbg.ActiveProcess; //Debugger.Processes.Active const string appDomainOption = "ad"; var ap = new ArgParser(arguments, appDomainOption + ":1"); if (!(ap.Count >= 1)) { throw new MDbgShellException("Not Enough arguments"); } // Currently debugger picks first function -- we have not implementing resolving overloaded functions. // Good example is Console.WriteLine -- there is 18 different types: // 1) [06000575] Void WriteLine() // 2) [06000576] Void WriteLine(Boolean) // 3) [06000577] Void WriteLine(Char) // 4) [06000578] Void WriteLine(Char[]) // 5) [06000579] Void WriteLine(Char[], Int32, Int32) // 6) [0600057a] Void WriteLine(Decimal) // 7) [0600057b] Void WriteLine(Double) // 8) [0600057c] Void WriteLine(Single) // 9) [0600057d] Void WriteLine(Int32) // 10) [0600057e] Void WriteLine(UInt32) // 11) [0600057f] Void WriteLine(Int64) // 12) [06000580] Void WriteLine(UInt64) // 13) [06000581] Void WriteLine(Object) // 14) [06000582] Void WriteLine(String) // 15) [06000583] Void WriteLine(String, Object) // 16) [06000584] Void WriteLine(String, Object, Object) // 17) [06000585] Void WriteLine(String, Object, Object, Object) // 18) [06000586] Void WriteLine(String, Object, Object, Object, Object, ...) // 19) [06000587] Void WriteLine(String, Object[]) // CorAppDomain appDomain; if (ap.OptionPassed(appDomainOption)) { MDbgAppDomain ad = activeProcess.AppDomains[ap.GetOption(appDomainOption).AsInt]; if (ad == null) { throw new ArgumentException("Invalid Appdomain Number"); } appDomain = ad.CorAppDomain; } else { appDomain = activeProcess.Threads.Active.CorThread.AppDomain; } MDbgFunction func = activeProcess.ResolveFunctionNameFromScope(ap.AsString(0), appDomain); if (null == func) { throw new MDbgShellException(String.Format(CultureInfo.InvariantCulture, "Could not resolve {0}", new Object[] { ap.AsString(0) })); } CorEval eval = activeProcess.Threads.Active.CorThread.CreateEval(); // Get Variables var vars = new ArrayList(); String arg; for (int i = 1; i < ap.Count; i++) { arg = ap.AsString(i); CorValue v = Shell.ExpressionParser.ParseExpression2(arg, activeProcess, activeProcess.Threads.Active. CurrentFrame); if (v == null) { throw new MDbgShellException("Cannot resolve expression or variable " + ap.AsString(i)); } if (v is CorGenericValue) { vars.Add(v); } else { CorHeapValue hv = v.CastToHeapValue(); if (hv != null) { // we cannot pass directly heap values, we need to pass reference to heap valus CorReferenceValue myref = eval.CreateValue(CorElementType.ELEMENT_TYPE_CLASS, null).CastToReferenceValue(); myref.Value = hv.Address; vars.Add(myref); } else { vars.Add(v); } } } eval.CallFunction(func.CorFunction, (CorValue[])vars.ToArray(typeof(CorValue))); activeProcess.Go().WaitOne(); // now display result of the funceval if (!(activeProcess.StopReason is EvalCompleteStopReason)) { // we could have received also EvalExceptionStopReason but it's derived from EvalCompleteStopReason Shell.IO.WriteOutput(MDbgOutputConstants.StdOutput, "Func-eval not fully completed and debuggee has stopped"); Shell.IO.WriteOutput(MDbgOutputConstants.StdOutput, "Result of funceval won't be printed when finished."); } else { eval = (activeProcess.StopReason as EvalCompleteStopReason).Eval; Debug.Assert(eval != null); CorValue cv = eval.Result; if (cv != null) { var mv = new MDbgValue(activeProcess, cv); if (execOnEval != null) // if this callback is set then execute { execOnEval(mv.GetStringValue(1)); return; } Shell.IO.WriteOutput(MDbgOutputConstants.StdOutput, "result = " + mv.GetStringValue(1)); if (cv.CastToReferenceValue() != null) { if (activeProcess.DebuggerVars.SetEvalResult(cv)) { Shell.IO.WriteOutput(MDbgOutputConstants.StdOutput, "results saved to $result"); } } } } } catch (Exception ex) { DI.log.ex(ex, "in FuncEvalCmd"); } if (execOnEval != null) // need to call this here so that the sync AutoResetEvent is set { execOnEval(null); } }
public static void PrintCmd(string arguments, O2Thread.FuncVoidT1 <string> o2Callback) { const string debuggerVarsOpt = "d"; const string noFuncevalOpt = "nf"; const string expandDepthOpt = "r"; var ap = new ArgParser(arguments, debuggerVarsOpt + ";" + noFuncevalOpt + ";" + expandDepthOpt + ":1"); bool canDoFunceval = !ap.OptionPassed(noFuncevalOpt); int?expandDepth = null; // we use optional here because // different codes bellow has different // default values. if (ap.OptionPassed(expandDepthOpt)) { expandDepth = ap.GetOption(expandDepthOpt).AsInt; if (expandDepth < 0) { throw new MDbgShellException("Depth cannot be negative."); } } MDbgFrame frame = CommandBase.Debugger.Processes.Active.Threads.Active.CurrentFrame; if (ap.OptionPassed(debuggerVarsOpt)) { // let's print all debugger variables MDbgProcess p = CommandBase.Debugger.Processes.Active; foreach (MDbgDebuggerVar dv in p.DebuggerVars) { var v = new MDbgValue(p, dv.CorValue); CommandBase.WriteOutput(dv.Name + "=" + v.GetStringValue(expandDepth == null ? 0 : (int)expandDepth, canDoFunceval)); } } else { if (ap.Count == 0) { // get all active variables MDbgFunction f = frame.Function; var vars = new ArrayList(); MDbgValue[] vals = f.GetActiveLocalVars(frame); if (vals != null) { vars.AddRange(vals); } vals = f.GetArguments(frame); if (vals != null) { vars.AddRange(vals); } foreach (MDbgValue v in vars) { CommandBase.WriteOutput(v.Name + "=" + v.GetStringValue(expandDepth == null ? 0 : (int)expandDepth, canDoFunceval)); } } else { // user requested printing of specific variables for (int j = 0; j < ap.Count; ++j) { MDbgValue var = CommandBase.Debugger.Processes.Active.ResolveVariable(ap.AsString(j), frame); if (var != null) { CommandBase.WriteOutput(ap.AsString(j) + "=" + var.GetStringValue(expandDepth == null ? 1 : (int)expandDepth, canDoFunceval)); } else { throw new MDbgShellException("Variable not found"); } } } } }
public static List <String> compileAllFilesIndividually(List <String> filesToCompile, O2Thread.FuncVoidT1 <string> currentTask, O2Thread.FuncVoidT1 <int> numberOfStepsToPerform, O2Thread.FuncVoid onStepEvent) { currentTask("Compiling all rules individualy (one file at the time)"); numberOfStepsToPerform(filesToCompile.Count); var compileEngine = new CompileEngine(); PublicDI.log.info("Compiling All XRules source code files ONE at the time"); var results = new List <String>(); foreach (var fileToCompile in filesToCompile) { var assembly = compileEngine.compileSourceFile(fileToCompile); if (assembly != null) { results.Add(assembly.Location); } else { PublicDI.log.error("In XRules_Execution.compileAllFilesIndividually, could not compile file: {0}", fileToCompile); } onStepEvent(); } return(results); }
public void EditRules(List<IO2Rule> o2RulesToEdit, O2Thread.FuncVoidT1<IO2Rule> _onSave) { this.invokeOnThread( () => { onSave = _onSave; newRule(); laDataSaved.Visible = false; btSaveRuleChanges.Enabled = false; btSaveChangesToAllRules.Enabled = true; laNumberOfRulesLoaded.Text = o2RulesToEdit.Count + " rule loaded"; o2LoadedRules = o2RulesToEdit; o2LoadedRule = null; }); }
public static List <String> getListOfAllFilesFromDirectory(String sStartDirectory, bool bSearchRecursively, O2Thread.FuncVoidT1 <List <String> > onComplete) { var lsFiles = new List <string>(); O2Thread.mtaThread( () => { getListOfAllFilesFromDirectory(lsFiles, sStartDirectory, bSearchRecursively, "*.*", false); onComplete(lsFiles); }); return(lsFiles); }
public Thread executeFilter(AvailableFilters filterToApply, bool addFindingsWithNoMatches, O2Thread.FuncVoidT1 <List <IO2Finding> > onCompletion) { var o2TargetO2Findings = findingsViewerSourceFindings.currentO2Findings; var o2RulesToUse = rulePackViewer.currentO2RulePack.o2Rules; return(O2Thread.mtaThread( () => { List <IO2Finding> mappedFidings = null; List <IO2Rule> o2Rules = o2RulesToUse.Cast <IO2Rule>().ToList(); switch (filterToApply) { case AvailableFilters.BasicSinksMapping: DI.log.info("Executing filter: BasicSinksMapping"); mappedFidings = Filter_BasicSinksMapping.applyFilter(o2TargetO2Findings, o2Rules); break; case AvailableFilters.CreateAllPartialTraces: DI.log.info("Executing filter: CreateAllPartialTraces"); mappedFidings = Filter_CreateAllPartialTraces.applyFilter(o2TargetO2Findings, o2Rules); break; case AvailableFilters.MapSinksToAllTraces: DI.log.info("Executing filter: MapSinksToAllTraces"); mappedFidings = Filter_MapSinksToAllTraces.applyFilter(o2TargetO2Findings, o2Rules, addFindingsWithNoMatches); break; case AvailableFilters.MapSourcesToAllTraces: DI.log.info("Executing filter: MapSourcesToAllTraces"); mappedFidings = Filter_MapSourcesToAllTraces.applyFilter(o2TargetO2Findings, o2Rules); break; case AvailableFilters.MapFirstSourcesThenSinksToAllTraces: DI.log.info("Executing filter: MapFirstSourcesThenSinksToAllTraces which has two steps"); DI.log.info("Step 1): MapFirstSourcesThenSinksToAllTraces->MapSourcesToAllTraces"); var sourceMappings = Filter_MapSourcesToAllTraces.applyFilter(o2TargetO2Findings, o2Rules); DI.log.info("Step 2): MapFirstSourcesThenSinksToAllTraces->MapSinksToAllTraces"); mappedFidings = Filter_MapSinksToAllTraces.applyFilter(sourceMappings, o2Rules, addFindingsWithNoMatches); break; } if (onCompletion != null) { onCompletion(mappedFidings); } })); }