protected Result(AnalysisMember source, Result parent, Exception exception, ExDateTime startTime, ExDateTime stopTime) { this.source = source; this.parent = parent; this.exception = exception; this.startTime = startTime; this.stopTime = stopTime; }
public Results <T> RelativeResults(Result relativeTo) { HashSet <AnalysisMember> @object = new HashSet <AnalysisMember>(base.AncestorsAndSelf()); AnalysisMember commonAncestor = relativeTo.Source.AncestorsAndSelf().First(new Func <AnalysisMember, bool>(@object.Contains)); Result result = relativeTo.AncestorsAndSelf().First((Result x) => x.Source == commonAncestor); return(result.DescendantsOfType <T>(this)); }
public IEnumerable <AnalysisMember> AncestorsAndSelf() { for (AnalysisMember current = this; current != null; current = current.Parent) { yield return(current); } yield break; }
public Result <T> AncestorOfType <T>(AnalysisMember <T> ancestor) { Result result = this.AncestorsAndSelf().FirstOrDefault((Result x) => x.Source == ancestor); if (ancestor != null) { return((Result <T>)result); } throw new AnalysisException(this.Source, Strings.ResultAncestorNotFound(ancestor.Name)); }
protected virtual void OnComplete() { AnalysisMember analysisMember = this as AnalysisMember; if (analysisMember == null || analysisMember is RootAnalysisMember) { return; } try { this.analysis.OnAnalysisMemberStop(analysisMember); } catch (Exception inner) { this.analysis.Cancel(new CriticalException(analysisMember, inner)); } bool isAnalysisComplete = false; if (analysisMember.IsConclusion) { AnalysisProgress unsafeValue = this.analysis.currentProgress.UnsafeValue; AnalysisProgress updatedProgress = new AnalysisProgress(unsafeValue.TotalConclusions, unsafeValue.CompletedConclusions + 1); isAnalysisComplete = (updatedProgress.CompletedConclusions == updatedProgress.TotalConclusions); this.analysis.currentProgress.Update(unsafeValue, updatedProgress, delegate(AnalysisProgress original, AnalysisProgress current, AnalysisProgress updated) { isAnalysisComplete = (updatedProgress.CompletedConclusions == updatedProgress.TotalConclusions); return(new AnalysisProgress(current.TotalConclusions, current.CompletedConclusions + 1)); }); EventHandler <ProgressUpdateEventArgs> progressUpdated = this.analysis.ProgressUpdated; if (progressUpdated != null) { try { progressUpdated(this.analysis, new ProgressUpdateEventArgs(updatedProgress)); } catch (Exception inner2) { this.analysis.Cancel(new CriticalException(analysisMember, inner2)); } } } if (isAnalysisComplete) { this.analysis.CompleteAnalysis(); } }
protected virtual void OnEvaluate(Result result) { AnalysisMember analysisMember = this as AnalysisMember; if (analysisMember == null || analysisMember is RootAnalysisMember) { return; } try { this.analysis.OnAnalysisMemberEvaluate(analysisMember, result); } catch (Exception inner) { this.analysis.Cancel(new CriticalException(analysisMember, inner)); } }
protected virtual void OnStart() { AnalysisMember analysisMember = this as AnalysisMember; if (analysisMember == null || analysisMember is RootAnalysisMember) { return; } try { this.analysis.OnAnalysisMemberStart(analysisMember); } catch (Exception inner) { this.analysis.Cancel(new CriticalException(analysisMember, inner)); } }
private TConclusion BuildConclusion(Analysis analysis, Result result) { if (result.Source == null) { result = new Result <object>((Result <object>)result, analysis.RootAnalysisMember, null, ExDateTime.Now, ExDateTime.Now); } AnalysisMember source = result.Source; if (source == analysis.RootAnalysisMember || (source.GetType().IsGenericType&& source.GetType().GetGenericTypeDefinition() == typeof(Setting <>))) { return((TConclusion)((object)this.BuildSettingConclusion(result))); } if (source is Rule) { return((TConclusion)((object)this.BuildRuleConclusion((RuleResult)result))); } return(default(TConclusion)); }
internal RuleResult(RuleResult toCopy, AnalysisMember source, Result parent, ExDateTime startTime, ExDateTime stopTime) : base(toCopy, source, parent, startTime, stopTime) { this.Severity = toCopy.Severity; }
public AccessedFailedResultException(AnalysisMember source, Exception inner) : base(source, Strings.AccessedFailedResult, inner) { }
protected override void OnAnalysisMemberEvaluate(Microsoft.Exchange.Management.Deployment.Analysis.AnalysisMember member, Microsoft.Exchange.Management.Deployment.Analysis.Result result) { }
public MultipleResultsException(AnalysisMember source) : base(source, Strings.AccessedValueWhenMultipleResults) { }
public CriticalException(AnalysisMember source, Exception inner) : base(source, Strings.CriticalMessage, inner) { }
public EmptyResultsException(AnalysisMember source) : base(source, Strings.EmptyResults) { }
protected abstract void OnAnalysisMemberEvaluate(AnalysisMember member, Result result);
protected abstract void OnAnalysisMemberStop(AnalysisMember member);
public void StartAnalysis() { Analysis.AnalysisState unsafeValue = this.currentState.UnsafeValue; if (unsafeValue.IsStarted || unsafeValue.IsCanceled) { return; } lock (this.startAnalysisLock) { Analysis.AnalysisState safeValue = this.currentState.SafeValue; if (safeValue.IsStarted || unsafeValue.IsCanceled) { return; } Analysis.AnalysisState updatedValue = safeValue.SetAsStarted(); this.currentState.Update(safeValue, updatedValue); } AnalysisProgress progress = this.currentProgress.Update(this.currentProgress.UnsafeValue, new AnalysisProgress((from x in this.AnalysisMembers where !(x is RootAnalysisMember) select x).Count((AnalysisMember x) => x.IsConclusion), 0)); try { this.OnAnalysisStart(); } catch (Exception inner) { this.Cancel(new CriticalException(null, inner)); } EventHandler <ProgressUpdateEventArgs> progressUpdated = this.ProgressUpdated; if (progressUpdated != null) { progressUpdated(this, new ProgressUpdateEventArgs(progress)); } List <AnalysisMember> source = (from x in this.AnalysisMembers where x.IsConclusion select x).ToList <AnalysisMember>(); if (source.Any <AnalysisMember>()) { if (this.threadMode == AnalysisThreading.Single) { using (IEnumerator <AnalysisMember> enumerator = (from x in source orderby(int) x.EvaluationMode select x).GetEnumerator()) { while (enumerator.MoveNext()) { AnalysisMember analysisMember = enumerator.Current; analysisMember.Start(); } return; } } using (IEnumerator <AnalysisMember> enumerator2 = (from x in this.AnalysisMembers where x.EvaluationMode == Evaluate.OnAnalysisStart && this.immediateEvaluationFilter(x) select x).GetEnumerator()) { while (enumerator2.MoveNext()) { AnalysisMember member = enumerator2.Current; Task.Factory.StartNew(delegate() { member.Start(); }, TaskCreationOptions.LongRunning); } } Parallel.ForEach <AnalysisMember>((from x in this.AnalysisMembers where x.IsConclusion && (x.EvaluationMode != Evaluate.OnAnalysisStart || !this.immediateEvaluationFilter(x)) select x).ToList <AnalysisMember>(), delegate(AnalysisMember x) { x.Start(); }); return; } this.CompleteAnalysis(); }
public Result(Result <T> toCopy, AnalysisMember source, Result parent, ExDateTime startTime, ExDateTime stopTime) : base(source, parent, toCopy.Exception, startTime, stopTime) { this.value = toCopy.ValueOrDefault; }
public AnalysisException(AnalysisMember source) { this.AnalysisMemberSource = source; }
public FilteredException(AnalysisMember source, Result filteredResult) : base(source, Strings.FilteredResult) { this.filteredResult = filteredResult; }
public AnalysisException(AnalysisMember source, string message, Exception inner) : base(message, inner) { this.AnalysisMemberSource = source; }
public FailureException(AnalysisMember source, string message) : base(source, message) { }
public Results <T> DescendantsOfType <T>(AnalysisMember <T> analysisMemeber) { return(new Results <T>(analysisMemeber, from x in analysisMemeber.Results where x.AncestorsAndSelf().Contains(this) select x)); }
protected override void OnAnalysisMemberStop(Microsoft.Exchange.Management.Deployment.Analysis.AnalysisMember member) { }
public CriticalException(AnalysisMember source, string message, Exception inner) : base(source, message, inner) { }
private IEnumerator <Result <T> > CreateProducerEnumerator() { AnalysisMember parent = base.Features.GetFeature <ForEachResultFeature>().ForEachResultFunc(); if (parent == null) { this.OnStart(); Result <T> rootResult = base.Analysis.RootAnalysisMember.UntypedResults.Single <Result>() as Result <T>; this.results = this.results.Add(rootResult); this.OnEvaluate(rootResult); yield return(rootResult); this.OnComplete(); } else { Func <Result, IEnumerable <Result> > resultFunc = base.Features.GetFeature <ResultsFeature>().ResultFunc; Func <FeatureSet, Result, bool> func; if (!base.Features.HasFeature <FilterFeature>()) { func = ((FeatureSet fs, Result r) => true); } else { func = base.Features.GetFeature <FilterFeature>().FilterFunc; } Func <FeatureSet, Result, bool> filterFunc = func; this.OnStart(); foreach (Result parentResult in parent.UntypedResults) { if (!parentResult.HasException) { ExDateTime startTime = ExDateTime.Now; Stopwatch stopWatch = Stopwatch.StartNew(); foreach (Result result in resultFunc(parentResult)) { Result <T> producerResult = (Result <T>)result; if (base.IsAnalysisCanceled) { yield break; } stopWatch.Stop(); ExDateTime stopTime = startTime + stopWatch.Elapsed; if (producerResult.HasException) { if (producerResult.Exception is AnalysisException) { AnalysisException ex = (AnalysisException)producerResult.Exception; ex.AnalysisMemberSource = this; } if (producerResult.Exception is CriticalException) { base.CancelAnalysis((CriticalException)producerResult.Exception); } } Result <T> filterResult = producerResult; try { if (!filterFunc(base.Features, producerResult)) { filterResult = new Result <T>(new FilteredException(this, producerResult)); } } catch (Exception inner) { base.CancelAnalysis(new CriticalException(this, inner)); } Result <T> consumerResult; if (filterResult is RuleResult) { RuleResult toCopy = filterResult as RuleResult; RuleResult ruleResult = new RuleResult(toCopy, this, parentResult, startTime, stopTime); consumerResult = (ruleResult as Result <T>); } else { consumerResult = new Result <T>(filterResult, this, parentResult, startTime, stopTime); } this.results = this.results.Add(consumerResult); this.OnEvaluate(consumerResult); yield return(consumerResult); startTime = stopTime; stopWatch.Restart(); } } } this.results = this.results.AsCompleted(); this.OnComplete(); } yield break; }