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