private Task StartProcessingAsync(ITestRequestHandler requestHandler, ITestHostManagerFactory managerFactory)
{
var task = new Task(
() =>
{
// Wait for the connection to the sender and start processing requests from sender
// Note that we are waiting here infinitely to connect to vstest.console, but at the same time vstest.console doesn't wait infinitely.
// It has a default timeout of 60secs(which is configurable), & then it kills testhost.exe
// The reason to wait infinitely, was remote debugging scenarios of UWP app,
// in such cases after the app gets launched, VS debugger takes control of it, & causes a lot of delay, which frequently causes timeout with vstest.console.
// One fix would be just double this timeout, but there is no telling how much time it can actually take.
// Hence we are waiting here indefinitely, to avoid such guessed timeouts, & letting user kill the debugging if they feel it is taking too much time.
// In other cases if vstest.console's timeout exceeds it will definitely such down the app.
if (requestHandler.WaitForRequestSenderConnection(ClientListenTimeOut))
{
EqtTrace.Info("DefaultEngineInvoker.StartProcessingAsync: Connected to vstest.console, Starting process requests.");
requestHandler.ProcessRequests(managerFactory);
}
else
{
EqtTrace.Info(
"DefaultEngineInvoker.StartProcessingAsync: RequestHandler timed out while connecting to the Sender.");
throw new TimeoutException();
}
},
TaskCreationOptions.LongRunning);
task.Start();
return(task);
}
private Task StartProcessingAsync(ITestRequestHandler requestHandler, ITestHostManagerFactory managerFactory)
{
return(Task.Run(() =>
{
// Wait for the connection to the sender and start processing requests from sender
if (requestHandler.WaitForRequestSenderConnection(ClientListenTimeOut))
{
requestHandler.ProcessRequests(managerFactory);
}
else
{
EqtTrace.Info("DefaultEngineInvoker: RequestHandler timed out while connecting to the Sender.");
throw new TimeoutException();
}
}));
}
private Task ProcessRequestsAsync(ITestHostManagerFactory testHostManagerFactory)
{
return(Task.Run(() => this.requestHandler.ProcessRequests(testHostManagerFactory)));
}
/// <summary>
/// Initializes a new instance of the <see cref="InProcessProxyDiscoveryManager"/> class.
/// </summary>
/// <param name="testHostManager">
/// The test Host Manager.
/// </param>
/// <param name="testHostManagerFactory">
/// Manager factory
/// </param>
public InProcessProxyDiscoveryManager(ITestRuntimeProvider testHostManager, ITestHostManagerFactory testHostManagerFactory)
{
this.testHostManager = testHostManager;
this.testHostManagerFactory = testHostManagerFactory;
this.discoveryManager = this.testHostManagerFactory.GetDiscoveryManager();
}
/// <inheritdoc />
public void ProcessRequests(ITestHostManagerFactory testHostManagerFactory)
{
this.testHostManagerFactory = testHostManagerFactory;
this.testHostManagerFactoryReady.Set();
this.sessionCompleted.Wait();
}
/// <summary>
/// Listens to the commands from server
/// </summary>
/// <param name="testHostManagerFactory">the test host manager.</param>
public void ProcessRequests(ITestHostManagerFactory testHostManagerFactory)
{
bool isSessionEnd = false;
var jobQueue = new JobQueue <Action>(
action => { action(); },
"TestHostOperationQueue",
500,
25000000,
true,
(message) => EqtTrace.Error(message));
do
{
var message = this.communicationManager.ReceiveMessage();
switch (message.MessageType)
{
case MessageType.VersionCheck:
var version = this.dataSerializer.DeserializePayload <int>(message);
this.protocolVersion = Math.Min(version, highestSupportedVersion);
this.communicationManager.SendMessage(MessageType.VersionCheck, this.protocolVersion);
// Can only do this after InitializeCommunication because TestHost cannot "Send Log" unless communications are initialized
if (!string.IsNullOrEmpty(EqtTrace.LogFile))
{
this.SendLog(TestMessageLevel.Informational, string.Format(CrossPlatResources.TesthostDiagLogOutputFile, EqtTrace.LogFile));
}
else if (!string.IsNullOrEmpty(EqtTrace.ErrorOnInitialization))
{
this.SendLog(TestMessageLevel.Warning, EqtTrace.ErrorOnInitialization);
}
break;
case MessageType.DiscoveryInitialize:
{
EqtTrace.Info("Discovery Session Initialize.");
var pathToAdditionalExtensions = this.dataSerializer.DeserializePayload <IEnumerable <string> >(message);
jobQueue.QueueJob(
() => testHostManagerFactory.GetDiscoveryManager()
.Initialize(pathToAdditionalExtensions),
0);
break;
}
case MessageType.StartDiscovery:
{
EqtTrace.Info("Discovery started.");
var discoveryEventsHandler = new TestDiscoveryEventHandler(this);
var discoveryCriteria = this.dataSerializer.DeserializePayload <DiscoveryCriteria>(message);
jobQueue.QueueJob(
() => testHostManagerFactory.GetDiscoveryManager()
.DiscoverTests(discoveryCriteria, discoveryEventsHandler),
0);
break;
}
case MessageType.ExecutionInitialize:
{
EqtTrace.Info("Discovery Session Initialize.");
var pathToAdditionalExtensions = this.dataSerializer.DeserializePayload <IEnumerable <string> >(message);
jobQueue.QueueJob(
() => testHostManagerFactory.GetExecutionManager()
.Initialize(pathToAdditionalExtensions),
0);
break;
}
case MessageType.StartTestExecutionWithSources:
{
EqtTrace.Info("Execution started.");
var testRunEventsHandler = new TestRunEventsHandler(this);
var testRunCriteriaWithSources = this.dataSerializer.DeserializePayload <TestRunCriteriaWithSources>(message);
jobQueue.QueueJob(
() =>
testHostManagerFactory.GetExecutionManager()
.StartTestRun(
testRunCriteriaWithSources.AdapterSourceMap,
testRunCriteriaWithSources.Package,
testRunCriteriaWithSources.RunSettings,
testRunCriteriaWithSources.TestExecutionContext,
this.GetTestCaseEventsHandler(testRunCriteriaWithSources.RunSettings),
testRunEventsHandler),
0);
break;
}
case MessageType.StartTestExecutionWithTests:
{
EqtTrace.Info("Execution started.");
var testRunEventsHandler = new TestRunEventsHandler(this);
var testRunCriteriaWithTests =
this.communicationManager.DeserializePayload <TestRunCriteriaWithTests>(message);
jobQueue.QueueJob(
() =>
testHostManagerFactory.GetExecutionManager()
.StartTestRun(
testRunCriteriaWithTests.Tests,
testRunCriteriaWithTests.Package,
testRunCriteriaWithTests.RunSettings,
testRunCriteriaWithTests.TestExecutionContext,
this.GetTestCaseEventsHandler(testRunCriteriaWithTests.RunSettings),
testRunEventsHandler),
0);
break;
}
case MessageType.CancelTestRun:
jobQueue.Pause();
testHostManagerFactory.GetExecutionManager().Cancel();
break;
case MessageType.LaunchAdapterProcessWithDebuggerAttachedCallback:
this.onAckMessageRecieved?.Invoke(message);
break;
case MessageType.AbortTestRun:
jobQueue.Pause();
testHostManagerFactory.GetExecutionManager().Abort();
break;
case MessageType.SessionEnd:
{
EqtTrace.Info("Session End message received from server. Closing the connection.");
isSessionEnd = true;
this.Close();
break;
}
case MessageType.SessionAbort:
{
// Dont do anything for now.
break;
}
default:
{
EqtTrace.Info("Invalid Message types");
break;
}
}
}while (!isSessionEnd);
}
/// <summary>
/// Initializes a new instance of the <see cref="InProcessProxyexecutionManager"/> class.
/// </summary>
/// <param name="testHostManager">
/// The test Host Manager.
/// </param>
/// <param name="testHostManagerFactory">
/// Manager factory
/// </param>
public InProcessProxyExecutionManager(ITestRuntimeProvider testHostManager, ITestHostManagerFactory testHostManagerFactory)
{
this.testHostManager = testHostManager;
this.testHostManagerFactory = testHostManagerFactory;
this.executionManager = this.testHostManagerFactory.GetExecutionManager();
}
/// <summary>
/// Listens to the commands from server
/// </summary>
/// <param name="testHostManagerFactory">the test host manager.</param>
public void ProcessRequests(ITestHostManagerFactory testHostManagerFactory)
{
bool isSessionEnd = false;
var jobQueue = new JobQueue <Action>(
(action) => { action(); },
"TestHostOperationQueue",
500,
25000000,
true,
(message) => EqtTrace.Error(message));
do
{
var message = this.communicationManager.ReceiveMessage();
switch (message.MessageType)
{
case MessageType.DiscoveryInitialize:
{
EqtTrace.Info("Discovery Session Initialize.");
var pathToAdditionalExtensions = message.Payload.ToObject <IEnumerable <string> >();
jobQueue.QueueJob(
() =>
testHostManagerFactory.GetDiscoveryManager().Initialize(pathToAdditionalExtensions), 0);
break;
}
case MessageType.StartDiscovery:
{
EqtTrace.Info("Discovery started.");
var discoveryEventsHandler = new TestDiscoveryEventHandler(this);
var discoveryCriteria = message.Payload.ToObject <DiscoveryCriteria>();
jobQueue.QueueJob(
() =>
testHostManagerFactory.GetDiscoveryManager()
.DiscoverTests(discoveryCriteria, discoveryEventsHandler), 0);
break;
}
case MessageType.ExecutionInitialize:
{
EqtTrace.Info("Discovery Session Initialize.");
var pathToAdditionalExtensions = message.Payload.ToObject <IEnumerable <string> >();
jobQueue.QueueJob(
() =>
testHostManagerFactory.GetExecutionManager().Initialize(pathToAdditionalExtensions), 0);
break;
}
case MessageType.StartTestExecutionWithSources:
{
EqtTrace.Info("Execution started.");
var testRunEventsHandler = new TestRunEventsHandler(this);
var testRunCriteriaWithSources = message.Payload.ToObject <TestRunCriteriaWithSources>();
jobQueue.QueueJob(
() =>
testHostManagerFactory.GetExecutionManager()
.StartTestRun(
testRunCriteriaWithSources.AdapterSourceMap,
testRunCriteriaWithSources.RunSettings,
testRunCriteriaWithSources.TestExecutionContext,
null,
testRunEventsHandler),
0);
break;
}
case MessageType.StartTestExecutionWithTests:
{
EqtTrace.Info("Execution started.");
var testRunEventsHandler = new TestRunEventsHandler(this);
var testRunCriteriaWithTests =
this.communicationManager.DeserializePayload <TestRunCriteriaWithTests>
(message);
jobQueue.QueueJob(
() =>
testHostManagerFactory.GetExecutionManager()
.StartTestRun(
testRunCriteriaWithTests.Tests,
testRunCriteriaWithTests.RunSettings,
testRunCriteriaWithTests.TestExecutionContext,
null,
testRunEventsHandler),
0);
break;
}
case MessageType.CancelTestRun:
jobQueue.Pause();
testHostManagerFactory.GetExecutionManager().Cancel();
break;
case MessageType.LaunchAdapterProcessWithDebuggerAttachedCallback:
this.OnAckMessageRecieved?.Invoke(message);
break;
case MessageType.AbortTestRun:
jobQueue.Pause();
testHostManagerFactory.GetExecutionManager().Abort();
break;
case MessageType.SessionEnd:
{
EqtTrace.Info("Session End message received from server. Closing the connection.");
isSessionEnd = true;
this.Close();
break;
}
case MessageType.SessionAbort:
{
// Dont do anything for now.
break;
}
default:
{
EqtTrace.Info("Invalid Message types");
break;
}
}
}while (!isSessionEnd);
}
