/// <inheritdoc />
public override IServiceEndpointClient <TMessage, TCommand, TEvent, TRequest, TResponse> CreateEndpointClient()
{
var serviceEndpointClient = new ServiceEndpointClient <TMessage, TCommand, TEvent, TRequest, TResponse>(
CreateSource <TEvent>(_cloudQueueClient, GetQueueName <TEvent>(_serviceName, DEFAULT_EVENTS_QUEUE_SUFFIX)),
CreateSource <TResponse>(_cloudQueueClient, GetQueueName <TResponse>(_serviceName, DEFAULT_RESPONSES_QUEUE_SUFFIX)),
CreatePublisher <TRequest>(_cloudQueueClient, GetQueueName <TRequest>(_serviceName, DEFAULT_REQUESTS_QUEUE_SUFFIX)),
CreatePublisher <TCommand>(_cloudQueueClient, GetQueueName <TCommand>(_serviceName, DEFAULT_COMMANDS_QUEUE_SUFFIX)),
typeof(TServiceMessage));
return(serviceEndpointClient);
}
public void ShouldDisposeSourcesAndPublishers()
{
IMessageSource <IResponse> responseSource = A.Fake <IMessageSource <IResponse> >();
IMessageSource <IEvent> eventSource = A.Fake <IMessageSource <IEvent> >();
IMessagePublisher <ICommand> commandPublisher = A.Fake <IMessagePublisher <ICommand> >();
IMessagePublisher <IRequest> requestPublisher = A.Fake <IMessagePublisher <IRequest> >();
IServiceEndpointClient endpoint = new ServiceEndpointClient(eventSource, responseSource, requestPublisher, commandPublisher, typeof(ITestServiceMessage1));
endpoint.Dispose();
A.CallTo(() => responseSource.Dispose()).MustHaveHappened(1, Times.Exactly);
A.CallTo(() => eventSource.Dispose()).MustHaveHappened(1, Times.Exactly);
A.CallTo(() => commandPublisher.Dispose()).MustHaveHappened(1, Times.Exactly);
A.CallTo(() => requestPublisher.Dispose()).MustHaveHappened(1, Times.Exactly);
}
public void ShouldDisposeSourcesAndPublishers()
{
IMessageSource<IResponse> responseSource = A.Fake<IMessageSource<IResponse>>();
IMessageSource<IEvent> eventSource = A.Fake<IMessageSource<IEvent>>();
IMessagePublisher<ICommand> commandPublisher = A.Fake<IMessagePublisher<ICommand>>();
IMessagePublisher<IRequest> requestPublisher = A.Fake<IMessagePublisher<IRequest>>();
IServiceEndpointClient endpoint = new ServiceEndpointClient(eventSource, responseSource, requestPublisher, commandPublisher, typeof(ITestServiceMessage1));
endpoint.Dispose();
A.CallTo(() => responseSource.Dispose()).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => eventSource.Dispose()).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => commandPublisher.Dispose()).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => requestPublisher.Dispose()).MustHaveHappened(Repeated.Exactly.Once);
}
public static void Main(string[] args)
{
ServiceEndpointClient serviceClient = new ServiceEndpointClient();
serviceClient.LoadAvailableDataCenters().Wait();
serviceClient.LoadAvailableServices().Wait();
var regClient = new ServiceRegistrationClient();
regClient
.Config(serviceName: "timsService", port: 7777, address: "localhost")
.AddSupportedVersions(new Version(1, 0, 0))
.AddHealthCheck("Health", 10, 20);
regClient.RegisterServiceAsync().Wait();
var host = new WebHostBuilder()
.UseKestrel()
.UseUrls("http://*:7777")
.UseStartup <Startup>()
.Build();
host.Run();
}
public void ShouldOnlySubscribeToUnderlyingMessageSourceEventsOnce()
{
var messageSource1 = A.Fake<IMessageSource<IEvent>>();
var messageSource2 = A.Fake<IMessageSource<IEvent>>();
IServiceEndpointClient serviceEndpointClient1 = new ServiceEndpointClient(
messageSource1,
A.Fake<IMessageSource<IResponse>>(),
A.Fake<IMessagePublisher<IRequest>>(),
A.Fake<IMessagePublisher<ICommand>>(),
typeof(IMessage));
IServiceEndpointClient serviceEndpointClient2 = new ServiceEndpointClient(
messageSource2,
A.Fake<IMessageSource<IResponse>>(),
A.Fake<IMessagePublisher<IRequest>>(),
A.Fake<IMessagePublisher<ICommand>>(),
typeof(IMessage));
int subscribed1 = 0;
int subscribed2 = 0;
int disposed1 = 0;
int disposed2 = 0;
IObservable<IEvent> observable1 = Observable.Create<IEvent>(observer =>
{
subscribed1++;
return Disposable.Create(() => disposed1++);
});
IObservable<IEvent> observable2 = Observable.Create<IEvent>(observer =>
{
subscribed2++;
return Disposable.Create(() => disposed2++);
});
A.CallTo(() => messageSource1.Messages).Returns(observable1);
A.CallTo(() => messageSource2.Messages).Returns(observable2);
IServiceBus serviceBus = new ServiceBus(new[] { serviceEndpointClient1, serviceEndpointClient2 }, new IServiceEndpoint[0]);
IObserver<IEvent> observer1 = A.Fake<IObserver<IEvent>>();
IObserver<IEvent> observer2 = A.Fake<IObserver<IEvent>>();
IObserver<IEvent> observer3 = A.Fake<IObserver<IEvent>>();
IObserver<IEvent> observer4 = A.Fake<IObserver<IEvent>>();
IDisposable sub1 = serviceBus.Events.Subscribe(observer1);
IDisposable sub2 = serviceBus.Events.Subscribe(observer2);
sub1.Dispose();
IDisposable sub3 = serviceBus.Events.Subscribe(observer3);
IDisposable sub4 = serviceBus.Events.Subscribe(observer4);
Assert.That(subscribed1, Is.EqualTo(1));
Assert.That(subscribed2, Is.EqualTo(1));
Assert.That(disposed1, Is.EqualTo(0));
Assert.That(disposed2, Is.EqualTo(0));
sub2.Dispose();
sub3.Dispose();
sub4.Dispose();
Assert.That(disposed1, Is.EqualTo(1));
Assert.That(disposed2, Is.EqualTo(1));
}
