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); }