static List <(long, TestOperationResult)> GetReceiverStoreData(
string source,
string resultType,
IEnumerable <ulong> resultValues,
IEnumerable <DateTime> timestamps,
Guid guid,
int start = 0)
{
var storeData = new List <(long, TestOperationResult)>();
int count = start;
for (int i = 0; i < resultValues.Count(); i++)
{
DirectMethodTestResult directMethodTestResult = new DirectMethodTestResult(
source,
timestamps.ElementAt(i),
"1",
guid,
resultValues.ElementAt(i),
HttpStatusCode.OK);
storeData.Add((count, new TestOperationResult(source, resultType, JsonConvert.SerializeObject(directMethodTestResult, Formatting.Indented), timestamps.ElementAt(i))));
count++;
}
return(storeData);
}
public async Task <ITestResultReport> CreateReportAsync()
{
long senderSuccesses = 0;
long receiverSuccesses = 0;
long statusCodeZero = 0;
Dictionary <HttpStatusCode, long> other = new Dictionary <HttpStatusCode, long>();
while (await this.SenderTestResults.MoveNextAsync())
{
this.ValidateDataSource(this.SenderTestResults.Current, this.SenderSource);
DirectMethodTestResult dmSenderTestResult = JsonConvert.DeserializeObject <DirectMethodTestResult>(this.SenderTestResults.Current.Result);
HttpStatusCode statusCode = dmSenderTestResult.HttpStatusCode;
switch ((int)statusCode)
{
case 0:
statusCodeZero++;
break;
case 200:
senderSuccesses++;
break;
default:
if (other.ContainsKey(statusCode))
{
other[statusCode]++;
}
else
{
other.Add(statusCode, 1);
}
break;
}
}
long receiverResults = 0;
while (await this.ReceiverTestResults.MoveNextAsync())
{
this.ValidateDataSource(this.ReceiverTestResults.Current, this.ReceiverSource);
DirectMethodTestResult dmReceiverTestResult = JsonConvert.DeserializeObject <DirectMethodTestResult>(this.ReceiverTestResults.Current.Result);
receiverResults++;
}
Logger.LogInformation($"Successfully finished creating {nameof(DirectMethodLongHaulReport)} for Sources [{this.SenderSource}] and [{this.ReceiverSource}]");
receiverSuccesses = receiverResults;
return(new DirectMethodLongHaulReport(
this.TestDescription,
this.trackingId,
this.SenderSource,
this.ReceiverSource,
this.ResultType,
senderSuccesses,
receiverSuccesses,
statusCodeZero,
other));
}
public async Task <ITestResultReport> CreateReportAsync()
{
ulong senderSuccesses = 0;
Option <ulong> receiverSuccesses = Option.None <ulong>();
ulong statusCodeZero = 0;
ulong unknown = 0;
while (await this.SenderTestResults.MoveNextAsync())
{
this.ValidateDataSource(this.SenderTestResults.Current, this.SenderSource);
DirectMethodTestResult dmSenderTestResult = JsonConvert.DeserializeObject <DirectMethodTestResult>(this.SenderTestResults.Current.Result);
switch ((int)dmSenderTestResult.HttpStatusCode)
{
case 0:
statusCodeZero++;
break;
case 200:
senderSuccesses++;
break;
default:
unknown++;
break;
}
}
await this.ReceiverTestResults.ForEachAsync(async r =>
{
ulong receiverResults = 0;
while (await r.MoveNextAsync())
{
// ReceiverSource will always be there if ReceiverTestResults is so it's safe to put OrDefault
this.ValidateDataSource(r.Current, this.ReceiverSource.Expect <ArgumentException>(
() => throw new ArgumentException("Impossible case. ReceiverSource must be filled in if ReceiverTestResults are")));
DirectMethodTestResult dmReceiverTestResult = JsonConvert.DeserializeObject <DirectMethodTestResult>(r.Current.Result);
receiverResults++;
}
receiverSuccesses = Option.Some(receiverResults);
});
return(new DirectMethodLongHaulReport(
this.TestDescription,
this.trackingId,
this.SenderSource,
this.ReceiverSource,
this.ResultType,
senderSuccesses,
receiverSuccesses,
statusCodeZero,
unknown));
}
async Task <DirectMethodReportGeneratorMetadata> ProcessSenderAndReceiverResults(
DirectMethodTestResult dmSenderTestResult,
bool hasSenderResult,
bool hasReceiverResult,
NetworkControllerStatus networkControllerStatus,
bool isWithinTolerancePeriod)
{
ulong mismatchSuccess = 0;
string receiverSource = this.ReceiverSource.OrDefault();
ITestResultCollection <TestOperationResult> receiverTestResults = this.ReceiverTestResults.OrDefault();
this.ValidateDataSource(receiverTestResults.Current, receiverSource);
DirectMethodTestResult dmReceiverTestResult = JsonConvert.DeserializeObject <DirectMethodTestResult>(receiverTestResults.Current.Result);
if (!string.Equals(dmSenderTestResult.TrackingId, dmReceiverTestResult.TrackingId, StringComparison.OrdinalIgnoreCase))
{
throw new InvalidDataException($"Sequence numbers should not match if the testResults didn't match. SenderTestResult: " +
$"{dmSenderTestResult.GetFormattedResult()}. ReceiverTestResult: {dmReceiverTestResult.GetFormattedResult()}");
}
if (string.Equals(dmSenderTestResult.SequenceNumber, dmReceiverTestResult.SequenceNumber, StringComparison.OrdinalIgnoreCase))
{
hasReceiverResult = await receiverTestResults.MoveNextAsync();
}
else
{
if (int.Parse(dmSenderTestResult.SequenceNumber) > int.Parse(dmReceiverTestResult.SequenceNumber))
{
return(await this.ProcessMismatchFailureCase());
}
else if (int.Parse(dmSenderTestResult.SequenceNumber) < int.Parse(dmReceiverTestResult.SequenceNumber))
{
if (HttpStatusCode.OK.Equals(dmSenderTestResult.HttpStatusCode) &&
(NetworkControllerStatus.Disabled.Equals(networkControllerStatus) ||
(NetworkControllerStatus.Enabled.Equals(networkControllerStatus) && isWithinTolerancePeriod)))
{
mismatchSuccess++;
hasSenderResult = await this.SenderTestResults.MoveNextAsync();
return(new DirectMethodReportGeneratorMetadata {
MismatchSuccess = mismatchSuccess, HasReceiverResult = hasReceiverResult, HasSenderResult = hasSenderResult
});
}
}
}
return(new DirectMethodReportGeneratorMetadata {
HasSenderResult = hasSenderResult, HasReceiverResult = hasReceiverResult
});
}
public async Task ReportTestResult()
{
await this.testResultReportingClient.ForEachAsync(
async (TestResultReportingClient testResultReportingClient) =>
{
DirectMethodTestResult testResult = new DirectMethodTestResult(this.configuration.GetValue <string>("IOTEDGE_MODULEID") + ".receive", DateTime.UtcNow)
{
TrackingId = this.trackingId.GetOrElse(string.Empty),
BatchId = this.batchId.ToString(),
SequenceNumber = this.directMethodCount.ToString(),
Result = HttpStatusCode.OK.ToString()
};
await ModuleUtil.ReportTestResultAsync(testResultReportingClient, this.logger, testResult);
});
}
public async Task ReportTestResult(string directMethodCount)
{
await this.testResultReportingClient.ForEachAsync(
async (TestResultReportingClient testResultReportingClient) =>
{
DirectMethodTestResult testResult = new DirectMethodTestResult(
this.configuration.GetValue <string>("IOTEDGE_MODULEID") + ".receive",
DateTime.UtcNow,
this.trackingId.GetOrElse(string.Empty),
this.batchId,
ulong.Parse(directMethodCount),
HttpStatusCode.OK);
await ModuleUtil.ReportTestResultAsync(testResultReportingClient, this.logger, testResult);
});
}
UnmatchedResultCounts CheckUnmatchedResult(
TestOperationResult testOperationResult,
NetworkControllerStatus networkControllerStatus,
bool isWithinTolerancePeriod)
{
ulong networkOffSuccess = 0;
ulong networkOnToleratedSuccess = 0;
ulong networkOnFailure = 0;
ulong mismatchSuccess = 0;
// int statusCodeInt = Int32.Parse(testOperationResult.Result.Split(";")[3]);
// HttpStatusCode statusCode = (HttpStatusCode)statusCodeInt;
DirectMethodTestResult dmTestResult = JsonConvert.DeserializeObject <DirectMethodTestResult>(testOperationResult.Result);
HttpStatusCode statusCode = JsonConvert.DeserializeObject <HttpStatusCode>(dmTestResult.Result);
if (HttpStatusCode.InternalServerError.Equals(statusCode))
{
if (NetworkControllerStatus.Enabled.Equals(networkControllerStatus))
{
// If the result is a failure AND network is offline, succeed
networkOffSuccess++;
}
else if (NetworkControllerStatus.Disabled.Equals(networkControllerStatus))
{
if (isWithinTolerancePeriod)
{
// If result is a failure and network is online, but we're within the tolerance period, succeed
networkOnToleratedSuccess++;
}
else
{
networkOnFailure++;
}
}
else
{
throw new InvalidOperationException($"Unexpected Result. NetworkControllerStatus was {networkControllerStatus}");
}
}
else
{
// Success, but no matching report from Actual store, means mismatch
mismatchSuccess++;
}
return(new UnmatchedResultCounts(networkOffSuccess, networkOnToleratedSuccess, networkOnFailure, mismatchSuccess));
}
bool IsMismatchSuccess(DirectMethodTestResult dmSenderTestResult, NetworkControllerStatus networkControllerStatus, bool isWithinTolerancePeriod)
{
if (HttpStatusCode.OK.Equals(dmSenderTestResult.HttpStatusCode))
{
if (!NetworkControllerType.Offline.Equals(this.NetworkControllerType))
{
return(true);
}
if (NetworkControllerStatus.Disabled.Equals(networkControllerStatus) ||
(NetworkControllerStatus.Enabled.Equals(networkControllerStatus) && isWithinTolerancePeriod))
{
return(true);
}
}
return(false);
}
public bool Matches(TestOperationResult value1, TestOperationResult value2)
{
if ((value1 == null && value2 != null) || (value1 != null && value2 == null))
{
return(false);
}
if (value1 == null && value2 == null)
{
return(true);
}
DirectMethodTestResult dmResult1 = JsonConvert.DeserializeObject <DirectMethodTestResult>(value1.Result);
DirectMethodTestResult dmResult2 = JsonConvert.DeserializeObject <DirectMethodTestResult>(value2.Result);
return(dmResult1.TrackingId == dmResult2.TrackingId &&
dmResult1.SequenceNumber == dmResult2.SequenceNumber &&
dmResult1.HttpStatusCode == dmResult2.HttpStatusCode);
}
public bool Matches(TestOperationResult value1, TestOperationResult value2)
{
if ((value1 == null && value2 != null) || (value1 != null && value2 == null))
{
return(false);
}
if (value1 == null && value2 == null)
{
return(true);
}
if (!TestOperationResultType.DirectMethod.ToString().Equals(value1.Type) || !TestOperationResultType.DirectMethod.ToString().Equals(value2.Type))
{
throw new InvalidDataException($"Incorrect TestOperationResult Type for comparer {nameof(DirectMethodTestOperationResultComparer)}. Types are: {value1.Type} and {value2.Type}");
}
DirectMethodTestResult dmtr1 = JsonConvert.DeserializeObject <DirectMethodTestResult>(value1.Result);
DirectMethodTestResult dmtr2 = JsonConvert.DeserializeObject <DirectMethodTestResult>(value2.Result);
return(string.Equals(dmtr1.SequenceNumber, dmtr2.SequenceNumber, StringComparison.OrdinalIgnoreCase));
}
// (sequenceNumber) is only valid if and only if (hasValue) is true
async Task <(ulong resultCount, bool hasValue, ulong sequenceNumber)> MoveNextReceiverResultAsync(ulong receiverResultCount)
{
bool hasValue = await this.ReceiverTestResults.MoveNextAsync();
ulong seqNum = 0;
if (!hasValue)
{
return(resultCount : receiverResultCount,
hasValue : hasValue,
sequenceNumber : seqNum);
}
receiverResultCount++;
DirectMethodTestResult receiverResult = JsonConvert.DeserializeObject <DirectMethodTestResult>(this.ReceiverTestResults.Current.Result);
seqNum = receiverResult.SequenceNumber;
return(resultCount : receiverResultCount,
hasValue : hasValue,
sequenceNumber : seqNum);
}
async Task <DirectMethodReportGeneratorMetadata> ProcessSenderTestResults(
DirectMethodTestResult dmSenderTestResult,
NetworkControllerStatus networkControllerStatus,
bool isWithinTolerancePeriod,
ITestResultCollection <TestOperationResult> senderTestResults)
{
ulong networkOnSuccess = 0;
ulong networkOffSuccess = 0;
ulong networkOnToleratedSuccess = 0;
ulong networkOffToleratedSuccess = 0;
ulong networkOnFailure = 0;
ulong networkOffFailure = 0;
HttpStatusCode statusCode = dmSenderTestResult.HttpStatusCode;
if (NetworkControllerStatus.Disabled.Equals(networkControllerStatus))
{
if (HttpStatusCode.OK.Equals(statusCode))
{
networkOnSuccess++;
}
else
{
if (isWithinTolerancePeriod)
{
networkOnToleratedSuccess++;
}
else
{
networkOnFailure++;
}
}
}
else if (NetworkControllerStatus.Enabled.Equals(networkControllerStatus))
{
if (HttpStatusCode.InternalServerError.Equals(statusCode))
{
networkOffSuccess++;
}
else if (HttpStatusCode.OK.Equals(dmSenderTestResult.HttpStatusCode))
{
if (isWithinTolerancePeriod)
{
networkOffToleratedSuccess++;
}
else
{
networkOffFailure++;
}
}
else
{
throw new InvalidDataException($"Unexpected HttpStatusCode of {statusCode}");
}
}
bool hasSenderResult = await senderTestResults.MoveNextAsync();
return(new DirectMethodReportGeneratorMetadata
{
NetworkOnSuccess = networkOnSuccess,
NetworkOffSuccess = networkOffSuccess,
NetworkOnToleratedSuccess = networkOnToleratedSuccess,
NetworkOffToleratedSuccess = networkOffToleratedSuccess,
NetworkOnFailure = networkOnFailure,
NetworkOffFailure = networkOffFailure,
HasSenderResult = hasSenderResult
});
}
async Task <DirectMethodReportGeneratorMetadata> ProcessSenderTestResults(
DirectMethodTestResult dmSenderTestResult,
NetworkControllerStatus networkControllerStatus,
bool isWithinTolerancePeriod,
IAsyncEnumerator <TestOperationResult> senderTestResults)
{
ulong networkOnSuccess = 0;
ulong networkOffSuccess = 0;
ulong networkOnToleratedSuccess = 0;
ulong networkOffToleratedSuccess = 0;
ulong networkOnFailure = 0;
ulong networkOffFailure = 0;
HttpStatusCode statusCode = dmSenderTestResult.HttpStatusCode;
if (!NetworkControllerType.Offline.Equals(this.NetworkControllerType))
{
if (HttpStatusCode.OK.Equals(statusCode))
{
networkOnSuccess++;
}
else
{
networkOnFailure++;
}
}
else if (NetworkControllerStatus.Disabled.Equals(networkControllerStatus))
{
if (HttpStatusCode.OK.Equals(statusCode))
{
networkOnSuccess++;
}
else
{
if (isWithinTolerancePeriod)
{
networkOnToleratedSuccess++;
}
else
{
networkOnFailure++;
}
}
}
else if (NetworkControllerStatus.Enabled.Equals(networkControllerStatus))
{
if (HttpStatusCode.NotFound.Equals(statusCode) || HttpStatusCode.FailedDependency.Equals(statusCode))
{
networkOffSuccess++;
}
else if (HttpStatusCode.OK.Equals(statusCode))
{
if (isWithinTolerancePeriod)
{
networkOffToleratedSuccess++;
}
else
{
networkOffFailure++;
}
}
else
{
networkOffFailure++;
}
}
bool hasSenderResult = await senderTestResults.MoveNextAsync();
return(new DirectMethodReportGeneratorMetadata
{
NetworkOnSuccess = networkOnSuccess,
NetworkOffSuccess = networkOffSuccess,
NetworkOnToleratedSuccess = networkOnToleratedSuccess,
NetworkOffToleratedSuccess = networkOffToleratedSuccess,
NetworkOnFailure = networkOnFailure,
NetworkOffFailure = networkOffFailure,
HasSenderResult = hasSenderResult
});
}
public async Task <ITestResultReport> CreateReportAsync()
{
long statusCodeZero = 0;
long senderSuccesses = 0;
long unauthorized = 0;
long deviceNotFound = 0;
long transientError = 0;
long resourceError = 0;
long notImplemented = 0;
long receiverSuccesses = 0;
Dictionary <HttpStatusCode, long> other = new Dictionary <HttpStatusCode, long>();
while (await this.SenderTestResults.MoveNextAsync())
{
this.ValidateDataSource(this.SenderTestResults.Current, this.SenderSource);
DirectMethodTestResult dmSenderTestResult = JsonConvert.DeserializeObject <DirectMethodTestResult>(this.SenderTestResults.Current.Result);
HttpStatusCode statusCode = dmSenderTestResult.HttpStatusCode;
switch ((int)statusCode)
{
case 0:
statusCodeZero++;
break;
case 200:
senderSuccesses++;
break;
case 401:
unauthorized++;
break;
case 404:
deviceNotFound++;
break;
case 424:
transientError++;
break;
case 503:
resourceError++;
break;
case 501:
notImplemented++;
break;
default:
if (other.ContainsKey(statusCode))
{
other[statusCode]++;
}
else
{
other.Add(statusCode, 1);
}
break;
}
}
long receiverResults = 0;
while (await this.ReceiverTestResults.MoveNextAsync())
{
this.ValidateDataSource(this.ReceiverTestResults.Current, this.ReceiverSource);
DirectMethodTestResult dmReceiverTestResult = JsonConvert.DeserializeObject <DirectMethodTestResult>(this.ReceiverTestResults.Current.Result);
receiverResults++;
}
Logger.LogInformation($"Successfully finished creating {nameof(DirectMethodLongHaulReport)} for Sources [{this.SenderSource}] and [{this.ReceiverSource}]");
receiverSuccesses = receiverResults;
return(new DirectMethodLongHaulReport(
this.TestDescription,
this.trackingId,
this.SenderSource,
this.ReceiverSource,
this.ResultType,
this.Topology,
this.MqttBrokerEnabled,
senderSuccesses,
receiverSuccesses,
statusCodeZero,
unauthorized,
deviceNotFound,
transientError,
resourceError,
notImplemented,
other));
}
async Task <DirectMethodReportGeneratorMetadata> ProcessSenderTestResults(
DirectMethodTestResult dmSenderTestResult,
NetworkControllerStatus networkControllerStatus,
bool isWithinTolerancePeriod,
IAsyncEnumerator <TestOperationResult> senderTestResults,
TimeSpan delay)
{
ulong networkOnSuccess = 0;
ulong networkOffSuccess = 0;
ulong networkOnToleratedSuccess = 0;
ulong networkOffToleratedSuccess = 0;
ulong networkOnFailure = 0;
ulong networkOffFailure = 0;
HttpStatusCode statusCode = dmSenderTestResult.HttpStatusCode;
if (!NetworkControllerType.Offline.Equals(this.NetworkControllerType))
{
if (HttpStatusCode.OK.Equals(statusCode))
{
networkOnSuccess++;
}
else
{
Logger.LogError($"Error: Type {this.NetworkControllerType}, statusCode {statusCode}, " +
$"Controller Status {networkControllerStatus}, iswithin tol {isWithinTolerancePeriod}, delay {delay}");
networkOnFailure++;
}
}
else if (NetworkControllerStatus.Disabled.Equals(networkControllerStatus))
{
if (HttpStatusCode.OK.Equals(statusCode))
{
networkOnSuccess++;
}
else
{
if (isWithinTolerancePeriod)
{
networkOnToleratedSuccess++;
}
else
{
Logger.LogError($"Error: Type {this.NetworkControllerType}, statusCode {statusCode}, " +
$"Controller Status {networkControllerStatus}, iswithin tol {isWithinTolerancePeriod}, delay {delay}");
networkOnFailure++;
}
}
}
else if (NetworkControllerStatus.Enabled.Equals(networkControllerStatus))
{
if (HttpStatusCode.NotFound.Equals(statusCode))
{
networkOffSuccess++;
}
else if (HttpStatusCode.OK.Equals(statusCode))
{
if (isWithinTolerancePeriod)
{
networkOffToleratedSuccess++;
}
else
{
Logger.LogError($"Error: Type {this.NetworkControllerType}, statusCode {statusCode}, " +
$"Controller Status {networkControllerStatus}, iswithin tol {isWithinTolerancePeriod}, delay {delay}");
networkOffFailure++;
}
}
else
{
Logger.LogError($"Error: Type {this.NetworkControllerType}, statusCode {statusCode}, " +
$"Controller Status {networkControllerStatus}, iswithin tol {isWithinTolerancePeriod}, delay {delay}");
networkOffFailure++;
}
}
bool hasSenderResult = await senderTestResults.MoveNextAsync();
return(new DirectMethodReportGeneratorMetadata
{
NetworkOnSuccess = networkOnSuccess,
NetworkOffSuccess = networkOffSuccess,
NetworkOnToleratedSuccess = networkOnToleratedSuccess,
NetworkOffToleratedSuccess = networkOffToleratedSuccess,
NetworkOnFailure = networkOnFailure,
NetworkOffFailure = networkOffFailure,
HasSenderResult = hasSenderResult
});
}
async Task <DirectMethodReportGeneratorMetadata> ProcessSenderAndReceiverResults(
DirectMethodTestResult dmSenderTestResult,
bool hasSenderResult,
bool hasReceiverResult,
NetworkControllerStatus networkControllerStatus,
bool isWithinTolerancePeriod)
{
ulong mismatchSuccess = 0;
string receiverSource = this.ReceiverSource.OrDefault();
IAsyncEnumerator <TestOperationResult> receiverTestResults = this.ReceiverTestResults.OrDefault();
this.ValidateDataSource(receiverTestResults.Current, receiverSource);
DirectMethodTestResult dmReceiverTestResult = JsonConvert.DeserializeObject <DirectMethodTestResult>(receiverTestResults.Current.Result);
if (!string.Equals(dmSenderTestResult.TrackingId, dmReceiverTestResult.TrackingId, StringComparison.OrdinalIgnoreCase))
{
throw new InvalidDataException($"Sequence numbers should not match if the testResults didn't match. SenderTestResult: " +
$"{dmSenderTestResult.GetFormattedResult()}. ReceiverTestResult: {dmReceiverTestResult.GetFormattedResult()}");
}
bool didFindMatch = false;
if (dmSenderTestResult.SequenceNumber == dmReceiverTestResult.SequenceNumber)
{
dmReceiverTestResult = JsonConvert.DeserializeObject <DirectMethodTestResult>(receiverTestResults.Current.Result);
didFindMatch = true;
ulong receiverSequenceNumber = dmReceiverTestResult.SequenceNumber;
while (hasReceiverResult && dmSenderTestResult.SequenceNumber == receiverSequenceNumber)
{
hasReceiverResult = await receiverTestResults.MoveNextAsync();
if (hasReceiverResult)
{
receiverSequenceNumber = JsonConvert.DeserializeObject <DirectMethodTestResult>(receiverTestResults.Current.Result).SequenceNumber;
}
}
}
if (!didFindMatch)
{
if (dmSenderTestResult.SequenceNumber > dmReceiverTestResult.SequenceNumber)
{
return(await this.ProcessMismatchFailureCase());
}
else if (dmSenderTestResult.SequenceNumber < dmReceiverTestResult.SequenceNumber)
{
if (this.IsMismatchSuccess(dmSenderTestResult, networkControllerStatus, isWithinTolerancePeriod))
{
mismatchSuccess++;
hasSenderResult = await this.SenderTestResults.MoveNextAsync();
return(new DirectMethodReportGeneratorMetadata {
MismatchSuccess = mismatchSuccess, HasReceiverResult = hasReceiverResult, HasSenderResult = hasSenderResult
});
}
}
}
return(new DirectMethodReportGeneratorMetadata {
HasSenderResult = hasSenderResult, HasReceiverResult = hasReceiverResult
});
}
public async Task <ITestResultReport> CreateReportAsync()
{
Logger.LogInformation($"Start to generate report by {nameof(DirectMethodConnectivityReportGenerator)} for Sources [{this.SenderSource}] and [{this.ReceiverSource}]");
ulong networkOnSuccess = 0;
ulong networkOffSuccess = 0;
ulong networkOnToleratedSuccess = 0;
ulong networkOffToleratedSuccess = 0;
ulong networkOnFailure = 0;
ulong networkOffFailure = 0;
ulong mismatchSuccess = 0;
ulong mismatchFailure = 0;
bool hasSenderResult = await this.SenderTestResults.MoveNextAsync();
bool hasReceiverResult = await this.ReceiverTestResults.Match(async x => await x.MoveNextAsync(), () => Task.FromResult(false));
DirectMethodReportGeneratorMetadata reportGeneratorMetadata;
while (hasSenderResult)
{
this.ValidateDataSource(this.SenderTestResults.Current, this.SenderSource);
(NetworkControllerStatus networkControllerStatus, bool isWithinTolerancePeriod, TimeSpan delay) =
this.NetworkStatusTimeline.GetNetworkControllerStatusAndWithinToleranceAt(this.SenderTestResults.Current.CreatedAt);
this.ValidateNetworkControllerStatus(networkControllerStatus);
DirectMethodTestResult dmSenderTestResult = JsonConvert.DeserializeObject <DirectMethodTestResult>(this.SenderTestResults.Current.Result);
if (hasReceiverResult)
{
reportGeneratorMetadata = await this.ProcessSenderAndReceiverResults(dmSenderTestResult, hasSenderResult, hasReceiverResult, networkControllerStatus, isWithinTolerancePeriod);
mismatchSuccess += reportGeneratorMetadata.MismatchSuccess;
mismatchFailure += reportGeneratorMetadata.MismatchFailure;
hasSenderResult = reportGeneratorMetadata.HasSenderResult;
hasReceiverResult = reportGeneratorMetadata.HasReceiverResult;
if (reportGeneratorMetadata.MismatchFailure > 0 || reportGeneratorMetadata.MismatchSuccess > 0)
{
continue;
}
}
reportGeneratorMetadata = await this.ProcessSenderTestResults(dmSenderTestResult, networkControllerStatus, isWithinTolerancePeriod, this.SenderTestResults, delay);
networkOnSuccess += reportGeneratorMetadata.NetworkOnSuccess;
networkOffSuccess += reportGeneratorMetadata.NetworkOffSuccess;
networkOnToleratedSuccess += reportGeneratorMetadata.NetworkOnToleratedSuccess;
networkOffToleratedSuccess += reportGeneratorMetadata.NetworkOffToleratedSuccess;
networkOnFailure += reportGeneratorMetadata.NetworkOnFailure;
networkOffFailure += reportGeneratorMetadata.NetworkOffFailure;
hasSenderResult = reportGeneratorMetadata.HasSenderResult;
}
while (hasReceiverResult)
{
reportGeneratorMetadata = await this.ProcessMismatchFailureCase();
mismatchFailure += reportGeneratorMetadata.MismatchFailure;
hasReceiverResult = reportGeneratorMetadata.HasReceiverResult;
}
Logger.LogInformation($"Successfully finished creating {nameof(DirectMethodConnectivityReport)} for Sources [{this.SenderSource}] and [{this.ReceiverSource}]");
return(new DirectMethodConnectivityReport(
this.TestDescription,
this.trackingId,
this.SenderSource,
this.ReceiverSource,
this.ResultType,
networkOnSuccess,
networkOffSuccess,
networkOnToleratedSuccess,
networkOffToleratedSuccess,
networkOnFailure,
networkOffFailure,
mismatchSuccess,
mismatchFailure));
}
public static async Task <int> MainAsync()
{
Logger.LogInformation($"Starting DirectMethodSender with the following settings:\r\n{Settings.Current}");
(CancellationTokenSource cts, ManualResetEventSlim completed, Option <object> handler) = ShutdownHandler.Init(TimeSpan.FromSeconds(5), Logger);
DirectMethodSenderBase directMethodClient = null;
ModuleClient reportClient = null;
Option <Uri> analyzerUrl = Settings.Current.AnalyzerUrl;
Option <Uri> testReportCoordinatorUrl = Settings.Current.TestResultCoordinatorUrl;
try
{
Guid batchId = Guid.NewGuid();
Logger.LogInformation($"Batch Id={batchId}");
directMethodClient = await CreateClientAsync(Settings.Current.InvocationSource);
reportClient = await ModuleUtil.CreateModuleClientAsync(
Settings.Current.TransportType,
ModuleUtil.DefaultTimeoutErrorDetectionStrategy,
ModuleUtil.DefaultTransientRetryStrategy,
Logger);
Logger.LogInformation($"Load gen delay start for {Settings.Current.TestStartDelay}.");
await Task.Delay(Settings.Current.TestStartDelay, cts.Token);
DateTime testStartAt = DateTime.UtcNow;
while (!cts.Token.IsCancellationRequested && IsTestTimeUp(testStartAt))
{
(HttpStatusCode result, long dmCounter) = await directMethodClient.InvokeDirectMethodAsync(cts);
// TODO: Create an abstract class to handle the reporting client generation
if (testReportCoordinatorUrl.HasValue)
{
await testReportCoordinatorUrl.ForEachAsync(
async (Uri uri) =>
{
var testResult = new DirectMethodTestResult(Settings.Current.ModuleId + ".send", DateTime.UtcNow)
{
TrackingId = Settings.Current.TrackingId.Expect(() => new ArgumentException("TrackingId is empty")),
BatchId = batchId.ToString(),
SequenceNumber = dmCounter.ToString(),
Result = result.ToString()
};
var testResultReportingClient = new TestResultReportingClient {
BaseUrl = uri.AbsoluteUri
};
await ModuleUtil.ReportTestResultAsync(testResultReportingClient, Logger, testResult);
});
}
else
{
await analyzerUrl.ForEachAsync(
async (Uri uri) =>
{
var testResult = new LegacyDirectMethodTestResult(Settings.Current.TargetModuleId, DateTime.UtcNow)
{
Result = result.ToString()
};
var testResultReportingClient = new TestResultReportingClient {
BaseUrl = uri.AbsoluteUri
};
await ModuleUtil.ReportTestResultAsync(testResultReportingClient, Logger, testResult);
},
async() =>
{
await reportClient.SendEventAsync("AnyOutput", new Message(Encoding.UTF8.GetBytes("Direct Method call succeeded.")));
});
}
await Task.Delay(Settings.Current.DirectMethodDelay, cts.Token);
}
await cts.Token.WhenCanceled();
}
catch (Exception e)
{
Logger.LogError(e, "Error occurred during direct method sender test setup");
}
finally
{
// Implicit CloseAsync()
directMethodClient?.Dispose();
reportClient?.Dispose();
}
completed.Set();
handler.ForEach(h => GC.KeepAlive(h));
Logger.LogInformation("DirectMethodSender Main() finished.");
return(0);
}
