protected override void EndProcessing()
{
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
writer.Close();
progress.RecordType = ProgressRecordType.Completed;
WriteProgress(progress);
Console.WriteLine("Done");
MAStatistics.StopOperation();
Console.WriteLine(MAStatistics.ToString());
if (this.timer != null)
{
this.timer.Stop();
this.timer.Elapsed -= this.timer_Elapsed;
}
if (writer != null)
{
writer.Close();
}
}
protected override void ProcessRecord()
{
foreach (AcmaPSObject obj in this.ExportObjects)
{
try
{
obj.Hologram.PreLoadAVPs();
CSEntryChangeXmlExport.ExportToXml(obj.Hologram, writer);
MAStatistics.AddImportOperation();
}
catch (Exception ex)
{
Console.WriteLine("Error exporting object {0}: {1}: {2}", this.currentObjectCount, obj.Hologram.ObjectID, ex.Message);
}
//progress.PercentComplete = Convert.ToInt32(((decimal)this.currentObjectCount / this.totalObjectCount) * 100);
progress.StatusDescription = string.Format("Importing {0}/{1}... {2} ({3} objects/sec)", this.currentObjectCount, this.totalObjectCount, obj.Hologram.ObjectID, this.sampleOpsSec);
progress.CurrentOperation = string.Format("Average rate: {0} objects/sec", this.averageOpsSec);
progress.SecondsRemaining = this.secondsRemaining;
this.WriteProgress(progress);
this.currentObjectCount++;
obj.Dispose();
}
}
public void ImportEnd(ImportReleaseRequest request)
{
try
{
CachedImportRequest originalRequest;
try
{
originalRequest = GetFromCache(request.Context);
}
catch (InvalidOperationException)
{
Logger.WriteLine("Could not release the request as it was not found in the cache");
return;
}
if (originalRequest.HighWatermark != null)
{
if (request.NormalTermination)
{
ActiveConfig.DB.ClearDeltas(originalRequest.HighWatermark);
}
}
RemoveFromCache(request.Context);
MAStatistics.StopOperation();
Logger.WriteLine(MAStatistics.ToString());
}
catch (Exception ex)
{
Logger.WriteLine("Could not release the request");
Logger.WriteException(ex);
}
}
protected override void ProcessRecord()
{
using (MAStatistics stats = this.MAInstance.Statistics)
{
this.WriteObject(stats);
}
}
public void ExportEnd()
{
Logger.WriteLine("Export Complete");
Logger.WriteSeparatorLine('*');
MAStatistics.StopOperation();
Logger.WriteLine(MAStatistics.ToString());
}
public void ExportStart()
{
Logger.WriteSeparatorLine('*');
Logger.WriteLine("Starting Export");
MAStatistics.StartOperation(MAOperationType.Export);
this.ProcessOperationEvents(AcmaEventOperationType.Export);
}
private void ProduceCSEntryChanges(ResultEnumerator results, Schema schema, CachedImportRequest request)
{
ParallelOptions op = new ParallelOptions();
op.CancellationToken = new CancellationToken();
request.CancellationToken = op.CancellationToken;
op.MaxDegreeOfParallelism = 1;
Parallel.ForEach(results, op, item =>
{
if (op.CancellationToken.IsCancellationRequested)
{
return;
}
string objectClassName = item.ObjectClass == null ? item.DeltaObjectClassName : item.ObjectClass.Name;
SchemaType type = schema.Types.FirstOrDefault(t => t.Name == objectClassName);
if (type == null)
{
return;
}
CSEntryChange csentry = null;
try
{
csentry = item.ToCSEntryChange(type);
MAStatistics.AddImportOperation();
}
catch (Exception ex)
{
MAStatistics.AddImportError();
if (csentry == null)
{
csentry = CSEntryChange.Create();
}
if (string.IsNullOrWhiteSpace(csentry.DN))
{
csentry.ErrorCodeImport = MAImportError.ImportErrorCustomStopRun;
}
else
{
csentry.ErrorCodeImport = MAImportError.ImportErrorCustomContinueRun;
}
csentry.ErrorName = ex.Message;
csentry.ErrorDetail = ex.StackTrace;
}
request.Queue.Enqueue(csentry);
});
request.ProducerComplete = true;
}
protected override void BeginProcessing()
{
try
{
if (this.ExportObjects == null || this.ExportObjects.Length == 0)
{
ThrowTerminatingError(new ErrorRecord(new ArgumentNullException("ExportObjects"), "NoObjects", ErrorCategory.InvalidArgument, null));
}
this.totalObjectCount = this.ExportObjects.Length;
Global.ThrowIfNotConnected(this);
this.writer = null;
MAStatistics.StartOperation(MAOperationType.Import);
Console.WriteLine("Writing export file... ");
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.IndentChars = " ";
settings.NewLineChars = Environment.NewLine;
writer = XmlWriter.Create(this.FileName, settings);
writer.WriteStartDocument();
writer.WriteStartElement("acma-export");
progress = new ProgressRecord(0, "Export", "Starting export");
this.operationStartTime = DateTime.Now;
this.sampleIntervalStartTime = DateTime.Now;
this.timer = new Timer(1000);
this.timer.Elapsed += this.timer_Elapsed;
this.timer.Start();
progress.RecordType = ProgressRecordType.Processing;
progress.PercentComplete = 0;
this.WriteProgress(progress);
}
catch (Exception ex)
{
if (this.timer != null)
{
this.timer.Stop();
this.timer.Elapsed -= this.timer_Elapsed;
this.timer = null;
}
if (writer != null)
{
writer.Close();
}
ThrowTerminatingError(new ErrorRecord(ex, "UnknownError", ErrorCategory.InvalidOperation, null));
}
}
public ImportResponse ImportStart(ImportStartRequest request)
{
Logger.WriteLine("Import request received");
MAStatistics.StartOperation(MAOperationType.Import);
ImportResponse response = new ImportResponse();
CachedImportRequest cachedRequest = new CachedImportRequest();
cachedRequest.Request = request;
if (cachedRequest.Request.ImportType == OperationType.Delta)
{
this.ProcessOperationEvents(AcmaEventOperationType.DeltaImport);
}
else
{
this.ProcessOperationEvents(AcmaEventOperationType.FullImport);
}
byte[] watermark = ActiveConfig.DB.GetHighWatermarkMAObjectsDelta();
response.Watermark = watermark == null ? null : Convert.ToBase64String(watermark);
cachedRequest.HighWatermark = watermark;
Logger.WriteLine("Got delta watermark: {0}", response.Watermark);
ResultEnumerator enumerator;
if (cachedRequest.Request.ImportType == OperationType.Delta)
{
enumerator = ActiveConfig.DB.EnumerateMAObjectsDelta(watermark);
}
else
{
enumerator = ActiveConfig.DB.EnumerateMAObjects(cachedRequest.Request.Schema.Types.Select(t => t.Name).ToList(), null, null);
}
cachedRequest.Queue = new ConcurrentQueue <CSEntryChange>();
cachedRequest.Count = enumerator.TotalCount;
this.StartProducerThread(enumerator, request.Schema, cachedRequest);
response.Context = Guid.NewGuid().ToString();
this.AddToCache(response.Context, cachedRequest);
this.GetResultPage(response, request.PageSize);
return(response);
}
public ExportResponse ExportPage(ExportRequest request)
{
try
{
Monitor.Enter(ServiceMain.Lock);
ExportResponse response = new ExportResponse();
response.Results = new List <CSEntryChangeResult>();
IList <AttributeChange> anchorchanges;
foreach (CSEntryChange csentryChange in request.CSEntryChanges)
{
try
{
bool referenceRetryRequired;
anchorchanges = CSEntryExport.PutExportEntry(csentryChange, out referenceRetryRequired);
if (referenceRetryRequired)
{
Logger.WriteLine(string.Format("Reference attribute not available for csentry {0}. Flagging for retry", csentryChange.DN));
response.Results.Add(CSEntryChangeResult.Create(csentryChange.Identifier, anchorchanges, MAExportError.ExportActionRetryReferenceAttribute));
}
else
{
response.Results.Add(CSEntryChangeResult.Create(csentryChange.Identifier, anchorchanges, MAExportError.Success));
}
}
catch (Exception ex)
{
MAStatistics.AddExportError();
response.Results.Add(this.GetExportChangeResultFromException(csentryChange, ex));
}
}
return(response);
}
finally
{
Monitor.Exit(ServiceMain.Lock);
}
}
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);
}
protected override void ProcessRecord()
{
Global.ThrowIfNotConnected(this);
try
{
UnitTestFile file = this.LoadUnitTestFile();
UnitTestFile.BreakOnTestFailure = this.BreakOnTestFailure;
MAStatistics.StartOperation(MAOperationType.Export);
Console.WriteLine(string.Empty.PadRight(79, '-'));
Console.WriteLine("Executing unit tests from: {0}", Path.GetFileName(ActiveConfig.XmlConfig.FileName));
Console.WriteLine();
UnitTest.UnitTestStartingEvent += UnitTest_UnitTestStartingEvent;
UnitTest.UnitTestCompletedEvent += UnitTest_UnitTestCompletedEvent;
UnitTestGroup.UnitTestGroupStartingEvent += UnitTestGroup_UnitTestGroupStartingEvent;
UnitTestGroup.UnitTestGroupCompletedEvent += UnitTestGroup_UnitTestGroupCompletedEvent;
UnitTestOutcomes report = file.Execute();
MAStatistics.StopOperation();
Console.WriteLine();
Console.WriteLine(string.Empty.PadRight(79, '-'));
if (report.TestCount > 0)
{
Console.WriteLine("Executed {0} tests", report.TestCount);
if (report.TestCount == report.TestSuccessfulCount)
{
Console.ForegroundColor = ConsoleColor.Green;
}
Console.WriteLine("{0} ({1}%) successful", report.TestSuccessfulCount, report.TestSuccessfulPercent.ToString("D"));
Console.ForegroundColor = ConsoleColor.Gray;
if (report.TestFailedCount > 0)
{
Console.ForegroundColor = ConsoleColor.Yellow;
}
Console.WriteLine("{0} ({1}%) failed", report.TestFailedCount, report.TestFailedPercent.ToString("D"));
Console.ForegroundColor = ConsoleColor.Gray;
if (report.TestInconclusiveCount > 0)
{
Console.ForegroundColor = ConsoleColor.Yellow;
}
Console.WriteLine("{0} ({1}%) inconclusive", report.TestInconclusiveCount, report.TestInconclusivePercent.ToString("D"));
Console.ForegroundColor = ConsoleColor.Gray;
if (report.TestErrorCount > 0)
{
Console.ForegroundColor = ConsoleColor.Red;
}
Console.WriteLine("{0} ({1}%) error{2}", report.TestErrorCount, report.TestErrorPercent.ToString("D"), report.TestErrorCount == 1 ? string.Empty : "s");
Console.ForegroundColor = ConsoleColor.Gray;
}
else
{
Console.WriteLine("No tests were executed");
}
Console.WriteLine(string.Empty.PadRight(79, '-'));
Console.WriteLine(MAStatistics.ToString());
Console.WriteLine(string.Empty.PadRight(79, '-'));
if (!string.IsNullOrWhiteSpace(this.HtmlReportFileName))
{
Console.Write("Writing test results to: {0}... ", this.HtmlReportFileName);
report.ToHtml(this.HtmlReportFileName);
Console.WriteLine("Done");
}
}
catch (Exception ex)
{
ErrorRecord error = new ErrorRecord(ex, "UnknownError", ErrorCategory.NotSpecified, null);
ThrowTerminatingError(error);
}
finally
{
UnitTest.UnitTestStartingEvent -= UnitTest_UnitTestStartingEvent;
UnitTest.UnitTestCompletedEvent -= UnitTest_UnitTestCompletedEvent;
UnitTestGroup.UnitTestGroupStartingEvent -= UnitTestGroup_UnitTestGroupStartingEvent;
UnitTestGroup.UnitTestGroupCompletedEvent -= UnitTestGroup_UnitTestGroupCompletedEvent;
}
}
protected override void ProcessRecord()
{
Global.ThrowIfNotConnected(this);
try
{
MAStatistics.StartOperation(MAOperationType.Export);
ActiveConfig.DB.CanCache = true;
Console.WriteLine("Reading import file... ");
StreamReader r = new StreamReader(this.FileName);
XmlReader reader = XmlReader.Create(r);
var doc = XDocument.Load(reader);
Console.WriteLine("Importing objects... ");
this.totalObjectCount = doc.Root.Elements().Count();
ProgressRecord progress = new ProgressRecord(0, "Import", "Starting import");
this.operationStartTime = DateTime.Now;
this.sampleIntervalStartTime = DateTime.Now;
this.timer = new Timer(1000);
this.timer.Elapsed += this.timer_Elapsed;
this.timer.Start();
progress.RecordType = ProgressRecordType.Processing;
progress.PercentComplete = 0;
this.WriteProgress(progress);
foreach (var node in doc.Root.Elements("object-change"))
{
bool refretry;
//XElement element = node;
AcmaCSEntryChange csentry = CSEntryChangeXmlImport.ImportFromXml(node, !this.IgnoreMissingAttributes.IsPresent);
progress.PercentComplete = Convert.ToInt32(((decimal)this.currentObjectCount / this.totalObjectCount) * 100);
progress.StatusDescription = string.Format("Importing {0}/{1}... {2} ({3} objects/sec)", this.currentObjectCount, this.totalObjectCount, csentry.DN, this.sampleOpsSec);
progress.CurrentOperation = string.Format("Average rate: {0} objects/sec", this.averageOpsSec);
progress.SecondsRemaining = this.secondsRemaining;
this.WriteProgress(progress);
try
{
CSEntryExport.PutExportEntry(csentry, out refretry);
}
catch (Exception ex)
{
Console.WriteLine("Error importing object {0}: {1}: {2}", this.currentObjectCount, csentry.DN, ex.Message);
}
this.currentObjectCount++;
}
progress.RecordType = ProgressRecordType.Completed;
WriteProgress(progress);
Console.WriteLine("Done");
MAStatistics.StopOperation();
Console.WriteLine(MAStatistics.ToString());
}
catch (Exception ex)
{
Logger.WriteException(ex);
ErrorRecord error = new ErrorRecord(ex, "UnknownError", ErrorCategory.NotSpecified, this.FileName);
ThrowTerminatingError(error);
}
finally
{
if (this.timer != null)
{
this.timer.Stop();
this.timer.Elapsed -= this.timer_Elapsed;
}
}
}
