/// <inheritdoc/>
public async Task ProcessTestRunAttachmentsAsync(IRequestData requestData, IEnumerable <AttachmentSet> attachments, ITestRunAttachmentsProcessingEventsHandler eventHandler, CancellationToken cancellationToken)
{
await InternalProcessTestRunAttachmentsAsync(requestData, new Collection <AttachmentSet>(attachments.ToList()), eventHandler, cancellationToken).ConfigureAwait(false);
}
private IMessageLogger CreateMessageLogger(ITestRunAttachmentsProcessingEventsHandler eventsHandler)
{
return(eventsHandler != null ? (IMessageLogger) new AttachmentsProcessingMessageLogger(eventsHandler) : new NullMessageLogger());
}
public AttachmentsProcessingMessageLogger(ITestRunAttachmentsProcessingEventsHandler eventsHandler)
{
this.eventsHandler = eventsHandler ?? throw new ArgumentNullException(nameof(eventsHandler));
}
private Collection <AttachmentSet> FinalizeOperation(IRequestData requestData, TestRunAttachmentsProcessingCompleteEventArgs completeArgs, Collection <AttachmentSet> attachments, Stopwatch stopwatch, ITestRunAttachmentsProcessingEventsHandler eventHandler)
{
testPlatformEventSource.TestRunAttachmentsProcessingStop(attachments.Count);
requestData.MetricsCollection.Add(TelemetryDataConstants.NumberOfAttachmentsAfterProcessing, attachments.Count);
requestData.MetricsCollection.Add(TelemetryDataConstants.AttachmentsProcessingState, completeArgs.Error != null ? AttachmentsProcessingFailed : completeArgs.IsCanceled ? AttachmentsProcessingCanceled : AttachmentsProcessingCompleted);
stopwatch.Stop();
requestData.MetricsCollection.Add(TelemetryDataConstants.TimeTakenInSecForAttachmentsProcessing, stopwatch.Elapsed.TotalSeconds);
completeArgs.Metrics = requestData.MetricsCollection.Metrics;
eventHandler?.HandleTestRunAttachmentsProcessingComplete(completeArgs, attachments);
return(attachments);
}
private async Task SendMessageAndListenAndReportAttachmentsProcessingResultAsync(IEnumerable <AttachmentSet> attachments, bool collectMetrics, ITestRunAttachmentsProcessingEventsHandler eventHandler, CancellationToken cancellationToken)
{
try
{
var payload = new TestRunAttachmentsProcessingPayload
{
Attachments = attachments,
CollectMetrics = collectMetrics
};
this.communicationManager.SendMessage(MessageType.TestRunAttachmentsProcessingStart, payload);
var isTestRunAttachmentsProcessingComplete = false;
using (cancellationToken.Register(() => this.communicationManager.SendMessage(MessageType.TestRunAttachmentsProcessingCancel)))
{
// Cycle through the messages that the vstest.console sends.
// Currently each of the operations are not separate tasks since they should not each take much time.
// This is just a notification.
while (!isTestRunAttachmentsProcessingComplete)
{
var message = await this.TryReceiveMessageAsync().ConfigureAwait(false);
if (string.Equals(MessageType.TestRunAttachmentsProcessingComplete, message.MessageType))
{
if (EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("VsTestConsoleRequestSender.SendMessageAndListenAndReportAttachments: Process complete.");
}
var testRunAttachmentsProcessingCompletePayload = this.dataSerializer.DeserializePayload <TestRunAttachmentsProcessingCompletePayload>(message);
eventHandler.HandleTestRunAttachmentsProcessingComplete(testRunAttachmentsProcessingCompletePayload.AttachmentsProcessingCompleteEventArgs, testRunAttachmentsProcessingCompletePayload.Attachments);
isTestRunAttachmentsProcessingComplete = true;
}
else if (string.Equals(MessageType.TestRunAttachmentsProcessingProgress, message.MessageType))
{
var testRunAttachmentsProcessingProgressPayload = this.dataSerializer.DeserializePayload <TestRunAttachmentsProcessingProgressPayload>(message);
eventHandler.HandleTestRunAttachmentsProcessingProgress(testRunAttachmentsProcessingProgressPayload.AttachmentsProcessingProgressEventArgs);
}
else if (string.Equals(MessageType.TestMessage, message.MessageType))
{
var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message);
eventHandler.HandleLogMessage(testMessagePayload.MessageLevel, testMessagePayload.Message);
}
else
{
EqtTrace.Warning($"VsTestConsoleRequestSender.SendMessageAndListenAndReportAttachments: Unexpected message received {message.MessageType}.");
}
}
}
}
catch (Exception exception)
{
EqtTrace.Error("Aborting Test Session End Operation: {0}", exception);
eventHandler.HandleLogMessage(TestMessageLevel.Error, TranslationLayerResources.AbortedTestRunAttachmentsProcessing);
eventHandler.HandleTestRunAttachmentsProcessingComplete(new TestRunAttachmentsProcessingCompleteEventArgs(false, exception), null);
// Earlier we were closing the connection with vstest.console in case of exceptions
// Removing that code because vstest.console might be in a healthy state and letting the client
// know of the error, so that the TL can wait for the next instruction from the client itself.
// Also, connection termination might not kill the process which could result in files being locked by testhost.
}
finally
{
this.testPlatformEventSource.TranslationLayerTestRunAttachmentsProcessingStop();
}
}
/// <inheritdoc/>
public Task ProcessTestRunAttachmentsAsync(IEnumerable <AttachmentSet> attachments, bool collectMetrics, ITestRunAttachmentsProcessingEventsHandler testSessionEventsHandler, CancellationToken cancellationToken)
{
return(this.SendMessageAndListenAndReportAttachmentsProcessingResultAsync(attachments, collectMetrics, testSessionEventsHandler, cancellationToken));
}
/// <inheritdoc/>
public async Task ProcessTestRunAttachmentsAsync(IEnumerable <AttachmentSet> attachments, string processingSettings, bool isLastBatch, bool collectMetrics, ITestRunAttachmentsProcessingEventsHandler testSessionEventsHandler, CancellationToken cancellationToken)
{
this.testPlatformEventSource.TranslationLayerTestRunAttachmentsProcessingStart();
await this.EnsureInitializedAsync().ConfigureAwait(false);
await requestSender.ProcessTestRunAttachmentsAsync(attachments, collectMetrics, testSessionEventsHandler, cancellationToken).ConfigureAwait(false);
}
/// <inheritdoc/>
public void ProcessTestRunAttachments(TestRunAttachmentsProcessingPayload attachmentsProcessingPayload, ITestRunAttachmentsProcessingEventsHandler attachmentsProcessingEventsHandler, ProtocolConfig protocolConfig)
{
EqtTrace.Info("TestRequestManager.ProcessTestRunAttachments: Test run attachments processing started.");
this.telemetryOptedIn = attachmentsProcessingPayload.CollectMetrics;
var requestData = this.GetRequestData(protocolConfig);
// Make sure to run the run request inside a lock as the below section is not thread-safe
// There can be only one discovery, execution or attachments processing request at a given point in time
lock (this.syncObject)
{
try
{
EqtTrace.Info("TestRequestManager.ProcessTestRunAttachments: Synchronization context taken");
this.testPlatformEventSource.TestRunAttachmentsProcessingRequestStart();
this.currentAttachmentsProcessingCancellationTokenSource = new CancellationTokenSource();
Task task = this.attachmentsProcessingManager.ProcessTestRunAttachmentsAsync(requestData, attachmentsProcessingPayload.Attachments, attachmentsProcessingEventsHandler, this.currentAttachmentsProcessingCancellationTokenSource.Token);
task.Wait();
}
finally
{
if (this.currentAttachmentsProcessingCancellationTokenSource != null)
{
this.currentAttachmentsProcessingCancellationTokenSource.Dispose();
this.currentAttachmentsProcessingCancellationTokenSource = null;
}
EqtTrace.Info("TestRequestManager.ProcessTestRunAttachments: Test run attachments processing completed.");
this.testPlatformEventSource.TestRunAttachmentsProcessingRequestStop();
// Post the attachments processing complete event
this.metricsPublisher.Result.PublishMetrics(TelemetryDataConstants.TestAttachmentsProcessingCompleteEvent, requestData.MetricsCollection.Metrics);
}
}
}
