private static string BuildSyncStepDetails(StepDetails d)
{
StringBuilder builder = new StringBuilder();
string stepDetails = string.Format(MessageBuilder.ThreeColumnHeader, 10, d.StepNumber, d.StepDefinition.StepTypeDescription, "Inbound");
builder.AppendFormat(MessageBuilder.FirstRow, stepDetails, "Projections", d.InboundFlowCounters.TotalProjections);
builder.AppendFormat(MessageBuilder.SimpleRow, "Joins", d.InboundFlowCounters.TotalJoins);
builder.AppendFormat(MessageBuilder.SimpleRow, "Filtered disconnectors", d.InboundFlowCounters.DisconnectorFiltered);
builder.AppendFormat(MessageBuilder.SimpleRow, "Disconnectors", d.InboundFlowCounters.DisconnectedRemains);
builder.AppendFormat(MessageBuilder.SimpleRow, "Connectors with flow updates", d.InboundFlowCounters.ConnectorFlow);
builder.AppendFormat(MessageBuilder.SimpleRow, "Connectors without flow updates", d.InboundFlowCounters.ConnectorNoFlow);
builder.AppendFormat(MessageBuilder.SimpleRow, "Filtered connectors", d.InboundFlowCounters.TotalFilteredConnectors);
builder.AppendFormat(MessageBuilder.SimpleRow, "Deleted connectors", d.InboundFlowCounters.TotalDeletedConnectors);
builder.AppendFormat(MessageBuilder.SimpleRow, "Metaverse object deletes", d.InboundFlowCounters.TotalMVObjectDeletes);
builder.AppendFormat(MessageBuilder.SimpleRow, "Flow errors", d.InboundFlowCounters.FlowFailure);
foreach (OutboundFlowCounters item in d.OutboundFlowCounters)
{
string f = string.Format(MessageBuilder.ThreeColumnHeader, 5, string.Empty, string.Empty, "Outbound: " + item.ManagementAgent);
builder.AppendFormat(MessageBuilder.FirstRow, f, "Export attribute flow", item.ConnectorFlow);
builder.AppendFormat(MessageBuilder.SimpleRow, "Provisioning adds", (item.ProvisionedAddFlow + item.ProvisionedAddNoFlow));
builder.AppendFormat(MessageBuilder.SimpleRow, "Provisioning renames", (item.ProvisionRenameFlow + item.ProvisionedRenameNoFlow));
builder.AppendFormat(MessageBuilder.SimpleRow, "Provisioning disconnects", item.ProvisionedDisconnect);
builder.AppendFormat(MessageBuilder.SimpleRow, "Provisioning delete-adds", (item.ProvisionedDeleteAddFlow + item.ProvisionedDeleteAddNoFlow));
}
return(builder.ToString());
}
internal void Step(CallStack callstack)
{
_stepWatch.Stop();
var stack = new string[callstack.elements.Count];
for (int i = 0; i < stack.Length; i++)
{
var objPath = callstack.elements[i].currentObject.path;
string stackElementName = "";
for (int c = 0; c < objPath.length; c++)
{
var comp = objPath.GetComponent(c);
if (!comp.isIndex)
{
stackElementName = comp.name;
break;
}
}
stack[i] = stackElementName;
}
_currStepStack = stack;
var currObj = callstack.currentElement.currentObject ?? callstack.currentElement.currentContainer;
_currStepDetails = new StepDetails {
type = currObj.GetType().Name,
detail = currObj.ToString()
};
_stepWatch.Start();
}
public static StepDetailsViewModel ToViewModel(this StepDetails entity)
{
return(new StepDetailsViewModel
{
StepId = entity.TestStepId,
StepName = entity.Description,
Status = entity.Status
});
}
private static string BuildExportErrorDetails(StepDetails d)
{
if (d.SynchronizationErrors.ExportErrors.Count == 0)
{
return(null);
}
IEnumerable <ExportError> errors;
int remainingErrors = 0;
if (Program.ActiveConfig.Settings.MailMaxErrors <= 0 || d.SynchronizationErrors.ExportErrors.Count <= Program.ActiveConfig.Settings.MailMaxErrors)
{
errors = d.SynchronizationErrors.ExportErrors;
}
else
{
errors = d.SynchronizationErrors.ExportErrors.Take(Program.ActiveConfig.Settings.MailMaxErrors);
remainingErrors = d.SynchronizationErrors.ExportErrors.Count - Program.ActiveConfig.Settings.MailMaxErrors;
}
StringBuilder errorsBuilder = new StringBuilder();
errorsBuilder.AppendLine("<h3>Export errors</h3>");
foreach (ExportError error in errors)
{
StringBuilder errorBuilder = new StringBuilder();
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "DN", error.DN);
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Error type", error.ErrorType);
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Date occurred", error.DateOccurred);
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "First occurred", error.FirstOccurred);
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Retry count", error.RetryCount);
if (error.CDError != null)
{
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Error code", error.CDError.ErrorCode);
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Error literal", error.CDError.ErrorLiteral);
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Server error detail", error.CDError.ServerErrorDetail);
}
errorsBuilder.AppendLine(string.Format(MessageBuilder.GetTemplate("ErrorTableFragment"), errorBuilder));
errorsBuilder.AppendLine("<br/>");
}
if (remainingErrors > 0)
{
errorsBuilder.Append($"There are {remainingErrors} more errors that are not shown in this report<br/>");
}
return(errorsBuilder.ToString());
}
internal void Step(CallStack callstack)
{
_stepWatch.Stop();
var stack = new string[callstack.elements.Count];
for (int i = 0; i < stack.Length; i++)
{
string stackElementName = "";
if (!callstack.elements[i].currentPointer.isNull)
{
var objPath = callstack.elements[i].currentPointer.path;
for (int c = 0; c < objPath.length; c++)
{
var comp = objPath.GetComponent(c);
if (!comp.isIndex)
{
stackElementName = comp.name;
break;
}
}
}
stack[i] = stackElementName;
}
_currStepStack = stack;
var currObj = callstack.currentElement.currentPointer.Resolve();
string stepType = null;
var controlCommandStep = currObj as ControlCommand;
if (controlCommandStep)
{
stepType = controlCommandStep.commandType.ToString() + " CC";
}
else
{
stepType = currObj.GetType().Name;
}
_currStepDetails = new StepDetails {
type = stepType,
obj = currObj
};
_stepWatch.Start();
}
private static string BuildExportStepDetails(StepDetails d)
{
StringBuilder builder = new StringBuilder();
string stepDetails = string.Format(MessageBuilder.TwoColumnHeader, 6, d.StepNumber, d.StepDefinition.StepTypeDescription);
builder.AppendFormat(MessageBuilder.FirstRow, stepDetails, "Export adds", d.ExportCounters.ExportAdd);
builder.AppendFormat(MessageBuilder.SimpleRow, "Export deletes", d.ExportCounters.ExportDelete);
builder.AppendFormat(MessageBuilder.SimpleRow, "Export delete-adds", d.ExportCounters.ExportDeleteAdd);
builder.AppendFormat(MessageBuilder.SimpleRow, "Export rename", d.ExportCounters.ExportRename);
builder.AppendFormat(MessageBuilder.SimpleRow, "Export update", d.ExportCounters.ExportUpdate);
builder.AppendFormat(MessageBuilder.SimpleRow, "Export failures", d.ExportCounters.ExportFailure);
return(builder.ToString());
}
private static string BuildImportStepDetails(StepDetails d)
{
StringBuilder builder = new StringBuilder();
string stepDetails = string.Format(MessageBuilder.TwoColumnHeader, 7, d.StepNumber, d.StepDefinition.StepTypeDescription);
builder.AppendFormat(MessageBuilder.FirstRow, stepDetails, "Import adds", d.StagingCounters.StageAdd);
builder.AppendFormat(MessageBuilder.SimpleRow, "Import deletes", d.StagingCounters.StageDelete);
builder.AppendFormat(MessageBuilder.SimpleRow, "Import delete-adds", d.StagingCounters.StageDeleteAdd);
builder.AppendFormat(MessageBuilder.SimpleRow, "Import rename", d.StagingCounters.StageRename);
builder.AppendFormat(MessageBuilder.SimpleRow, "Import update", d.StagingCounters.StageUpdate);
builder.AppendFormat(MessageBuilder.SimpleRow, "Import no change", d.StagingCounters.StageNoChange);
builder.AppendFormat(MessageBuilder.SimpleRow, "Import failures", d.StagingCounters.StageFailure);
return(builder.ToString());
}
private static string BuildSyncErrorDetails(StepDetails d)
{
if (d.MVRetryErrors == null || d.MVRetryErrors.Count == 0)
{
return(null);
}
IEnumerable <MVRetryError> errors;
int remainingErrors = 0;
if (Program.ActiveConfig.Settings.MailMaxErrors <= 0 || d.MVRetryErrors.Count <= Program.ActiveConfig.Settings.MailMaxErrors)
{
errors = d.MVRetryErrors;
}
else
{
errors = d.MVRetryErrors.Take(Program.ActiveConfig.Settings.MailMaxErrors);
remainingErrors = d.MVRetryErrors.Count - Program.ActiveConfig.Settings.MailMaxErrors;
}
StringBuilder errorsBuilder = new StringBuilder();
errorsBuilder.AppendLine("<h3>Outbound synchronization errors</h3>");
foreach (MVRetryError error in errors)
{
StringBuilder errorBuilder = new StringBuilder();
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Object", error.DisplayName ?? error.MVID);
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Step", error.AlgorithmStep?.Value);
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Error type", error.ErrorType);
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Date occurred", error.DateOccurred);
MessageBuilder.BuildErrorExtensionInfo(error.ExtensionErrorInfo, errorBuilder);
MessageBuilder.BuildRulesErrorInfo(error.RulesErrorInfo, errorBuilder);
errorsBuilder.AppendLine(string.Format(MessageBuilder.GetTemplate("ErrorTableFragment"), errorBuilder));
errorsBuilder.AppendLine("<br/>");
}
if (remainingErrors > 0)
{
errorsBuilder.Append($"There are {remainingErrors} more errors that are not shown in this report<br/>");
}
return(errorsBuilder.ToString());
}
private bool GetCounts(StepDetails d, out int processed, out double total)
{
processed = 0;
total = 0;
switch (d.StepDefinition.Type)
{
case RunStepType.Export:
total = this.stats.PendingExportTotal;
processed = d.ExportCounters.ExportAdd + d.ExportCounters.ExportDelete + d.ExportCounters.ExportDeleteAdd + d.ExportCounters.ExportDeleteAdd + d.ExportCounters.ExportFailure + d.ExportCounters.ExportRename + d.ExportCounters.ExportUpdate;
break;
case RunStepType.DeltaImport:
case RunStepType.DeltaImportDeltaSynchronization:
total = 0;
processed = d.StagingCounters.StageAdd + d.StagingCounters.StageDelete + d.StagingCounters.StageDeleteAdd + d.StagingCounters.StageFailure + d.StagingCounters.StageNoChange + d.StagingCounters.StageRename + d.StagingCounters.StageUpdate;
return(false);
case RunStepType.FullSynchronization:
total = this.stats.Total;
processed = d.InboundFlowCounters.ConnectorFlow + d.InboundFlowCounters.ConnectorNoFlow + d.InboundFlowCounters.DisconnectedRemains + d.InboundFlowCounters.DisconnectorFiltered;
break;
case RunStepType.DeltaSynchronization:
total = this.stats.PendingImportTotal;
processed = d.InboundFlowCounters.ConnectorFlow + d.InboundFlowCounters.ConnectorNoFlow + d.InboundFlowCounters.DisconnectedRemains + d.InboundFlowCounters.DisconnectorFiltered;
break;
case RunStepType.FullImport:
case RunStepType.FullImportFullSynchronization:
case RunStepType.FullImportDeltaSynchronization:
total = this.stats.Total;
processed = d.StagingCounters.StageAdd + d.StagingCounters.StageDelete + d.StagingCounters.StageDeleteAdd + d.StagingCounters.StageFailure + d.StagingCounters.StageNoChange + d.StagingCounters.StageRename + d.StagingCounters.StageUpdate;
break;
default:
return(false);
}
return(true);
}
public ExecutionContext(Specification specification, Scenario scenario, StepDetails stepDetails)
{
this.CurrentSpecification = specification;
this.CurrentScenario = scenario;
this.CurrentStep = stepDetails;
}
public static bool HasUnconfirmedExports(this StepDetails s)
{
return(s?.ExportCounters?.HasChanges ?? false);
}
protected void UpdateProgress(bool pending, int runNumber)
{
if (runNumber < 0)
{
return;
}
RunDetails s = this.MAInstance.GetRunDetail(runNumber);
if (s == null)
{
return;
}
if (this.runProfile == null)
{
this.runProfile = this.MAInstance.RunProfiles[s.RunProfileName];
this.stats = this.MAInstance.Statistics;
}
StepDetails d = s.StepDetails.FirstOrDefault();
if (d == null)
{
return;
}
string description;
if (pending)
{
description = $"Waiting for {this.MAInstance.Name} to finish {s.RunProfileName}";
}
else
{
description = this.MAInstance.Name;
}
if (this.lastStepNumber == 0 || this.lastStepNumber != d.StepNumber)
{
this.lastStepNumber = d.StepNumber;
this.countHistory = new FixedSizedQueue <ProgressItem>(30);
}
ProgressRecord r = new ProgressRecord(0, description, string.Format(
$"Performing {this.runProfile.Name} step {d.StepNumber}/{this.runProfile.RunSteps.Count}: {d.StepDefinition.StepTypeDescription}"))
{
RecordType = ProgressRecordType.Processing
};
int processed;
double total;
int remaining = 0;
if (this.GetCounts(d, out processed, out total))
{
int percentComplete = (int)((processed / total) * 100);
r.PercentComplete = percentComplete > 100 ? 0 : percentComplete;
remaining = (int)total - processed;
}
if (processed > 0)
{
double objpersec = 0;
int changedCount;
TimeSpan?timespan;
this.GetCountDiff(processed, out changedCount, out timespan);
if (changedCount > 0 && timespan.HasValue)
{
objpersec = changedCount / timespan.Value.TotalSeconds;
}
if (remaining > 0 && objpersec > 0)
{
int remainingSeconds = (int)(remaining / objpersec);
r.SecondsRemaining = remainingSeconds > 0 ? remainingSeconds : 0;
}
if (objpersec > 0 && !double.IsInfinity(objpersec))
{
r.StatusDescription += $" ({objpersec:N2} obj/sec)";
}
}
else
{
r.StatusDescription += " (waiting for MA to start)";
}
this.WriteProgress(r);
}
private static string BuildStagingErrorDetails(StepDetails d)
{
if (d.MADiscoveryErrors.Count == 0)
{
return(null);
}
IEnumerable <MAObjectError> errors;
int remainingErrors = 0;
if (Program.ActiveConfig.Settings.MailMaxErrors <= 0 || d.MADiscoveryErrors.Count <= Program.ActiveConfig.Settings.MailMaxErrors)
{
errors = d.MADiscoveryErrors;
}
else
{
errors = d.MADiscoveryErrors.Take(Program.ActiveConfig.Settings.MailMaxErrors);
remainingErrors = d.MADiscoveryErrors.Count - Program.ActiveConfig.Settings.MailMaxErrors;
}
StringBuilder errorsBuilder = new StringBuilder();
errorsBuilder.AppendLine("<h3>Staging errors</h3>");
foreach (MAObjectError error in errors)
{
StringBuilder errorBuilder = new StringBuilder();
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "DN", error.DN);
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Error type", error.ErrorType);
if (error.CDError != null)
{
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Error code", error.CDError.ErrorCode);
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Error literal", error.CDError.ErrorLiteral);
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Server error detail", error.CDError.ServerErrorDetail);
if (error.CDError.Value != null)
{
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Value", string.Join(", ", error.CDError.Value));
}
}
if (error.LineNumber > 0)
{
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Line number", error.LineNumber);
}
if (error.ColumnNumber > 0)
{
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Column number", error.ColumnNumber);
}
if (error.AttributeName != null)
{
errorBuilder.AppendFormat(MessageBuilder.SimpleRow, "Attribute name", error.AttributeName);
}
errorsBuilder.AppendLine(string.Format(MessageBuilder.GetTemplate("ErrorTableFragment"), errorBuilder));
errorsBuilder.AppendLine("<br/>");
}
if (remainingErrors > 0)
{
errorsBuilder.Append($"There are {remainingErrors} more errors that are not shown in this report<br/>");
}
return(errorsBuilder.ToString());
}
