static void EstablishInitialMockSetups() { subscription_policies .SetupGet(_ => _.Connecting) .Returns(() => { var policy = new Mock <IAsyncPolicy>(); policy.Setup(_ => _.ExecuteAsync(Moq.It.IsAny <Func <CancellationToken, Task> >(), Moq.It.IsAny <CancellationToken>())) .Returns <Func <CancellationToken, Task>, CancellationToken>((callback, cancellationToken) => Task.Run(async() => { while (!policy_cts.Token.IsCancellationRequested && !cancellationToken.IsCancellationRequested) { try { await callback(cancellationToken).ConfigureAwait(false); } catch { } await Task.Delay(10).ConfigureAwait(false); } })); return(policy.Object); }); event_horizon_connection = new Mock <IEventHorizonConnection>(); event_horizon_connection_factory .Setup(_ => _.Create(producer_microservice_address, execution_context)) .Returns(event_horizon_connection.Object); event_horizon_connection .Setup(_ => _.Connect(subscription_id, Moq.It.IsAny <StreamPosition>(), Moq.It.IsAny <CancellationToken>())) .Returns(Task.FromResult(SubscriptionResponse.Succeeded(consent))); get_next_event .Setup(_ => _.GetNextEventToReceiveFor(subscription_id, Moq.It.IsAny <CancellationToken>())) .Returns(Task.FromResult(subscription_stream_position)); stream_processor = new Mock <IStreamProcessor>(); stream_processor_factory .Setup(_ => _.Create(Moq.It.IsAny <ConsentId>(), subscription_id, execution_context, Moq.It.IsAny <EventsFromEventHorizonFetcher>())) .Returns(stream_processor.Object); stream_processor .Setup(_ => _.StartAndWait(Moq.It.IsAny <CancellationToken>())) .Returns <CancellationToken>(cancellationToken => Task.Run(async() => { while (!stream_processor_cts.Token.IsCancellationRequested && !cancellationToken.IsCancellationRequested) { await Task.Delay(50).ConfigureAwait(false); } })); event_horizon_connection .Setup(_ => _.StartReceivingEventsInto(Moq.It.IsAny <AsyncProducerConsumerQueue <StreamEvent> >(), Moq.It.IsAny <CancellationToken>())) .Returns <AsyncProducerConsumerQueue <StreamEvent>, CancellationToken>((_, cancellationToken) => Task.Run(async() => { while (!event_horizon_connection_cts.Token.IsCancellationRequested && !cancellationToken.IsCancellationRequested) { await Task.Delay(50).ConfigureAwait(false); } })); }
/// <inheritdoc/> public async Task <SubscriptionResponse> Connect( SubscriptionId subscription, StreamPosition publicEventsPosition, CancellationToken cancellationToken) { _metrics.IncrementTotalConnectionAttempts(); var watch = new Stopwatch(); watch.Start(); if (await _reverseCallClient.Connect(CreateRequest(subscription, publicEventsPosition), _executionContext, cancellationToken).ConfigureAwait(false)) { watch.Stop(); _metrics.AddTotalTimeSpentConnecting(watch.Elapsed); _subscriptionId = subscription; var response = _reverseCallClient.ConnectResponse; if (response.Failure != default) { _metrics.IncrementTotalFailureResponses(); _logger.ConnectionToProducerRuntimeFailed(subscription, response.Failure.Reason); if (response.Failure.Id.ToGuid() == Producer.SubscriptionFailures.MissingConsent.Value) { _metrics.IncrementTotalSubscriptionsWithMissingConsent(); } if (response.Failure.Id.ToGuid() == Producer.SubscriptionFailures.MissingSubscriptionArguments.Value) { _metrics.IncrementTotalSubcriptionsWithMissingArguments(); } return(SubscriptionResponse.Failed(response.Failure)); } _metrics.IncrementTotalSuccessfulResponses(); _logger.ConnectionToProducerRuntimeSucceeded(subscription); return(SubscriptionResponse.Succeeded(response.ConsentId.ToGuid())); } watch.Stop(); _metrics.IncrementTotalConnectionsFailed(); _logger.CouldNotConnectToProducerRuntime(subscription); return(SubscriptionResponse.Failed( new Failure( SubscriptionFailures.CouldNotConnectToProducerRuntime, "Could not connect to producer Runtime"))); }