public async Task <MicrowaveServiceNode> GetConsumingServiceNodes()
{
var eventLocation = await _statusRepository.GetEventLocation();
return(MicrowaveServiceNode.ReachableMicrowaveServiceNode(new ServiceEndPoint(null, _configuration.ServiceName),
eventLocation.Services.Select(s => s.ServiceEndPoint)));
}
private void SetDomainEventLocation(MicrowaveServiceNode microwaveServiceNodePublishStuff)
{
var servicesWithoutAddedService = Services.Where(s => s.ServiceEndPoint.ServiceBaseAddress != microwaveServiceNodePublishStuff.ServiceEndPoint.ServiceBaseAddress);
var services = servicesWithoutAddedService.Append(microwaveServiceNodePublishStuff);
Services = services;
}
public async Task <MicrowaveServiceNode> GetDependantServices(Uri serviceAddress)
{
var client = await _factory.GetClient(serviceAddress);
try
{
var response = await client.GetAsync("Dicovery/ServiceDependencies");
_logger.LogTrace($"Response for Servicedependencies was {response.StatusCode}");
if (!response.IsSuccessStatusCode)
{
return(MicrowaveServiceNode.UnreachableMicrowaveServiceNode(new ServiceEndPoint(serviceAddress), new List <ServiceEndPoint>()));
}
var content = await response.Content.ReadAsStringAsync();
var remoteNode = JsonConvert.DeserializeObject <MicrowaveServiceNodeDto>(content);
var newNode = MicrowaveServiceNode.ReachableMicrowaveServiceNode(
new ServiceEndPoint(serviceAddress, remoteNode.ServiceEndPoint.Name),
remoteNode.ConnectedServices);
return(newNode);
}
catch (HttpRequestException)
{
return(MicrowaveServiceNode.UnreachableMicrowaveServiceNode(new ServiceEndPoint(serviceAddress), new List <ServiceEndPoint>()));
}
}
public async Task <ServiceMap> GetServiceMap()
{
var mongoCollection = _database.GetCollection <ServiceMapDbo>(StatusDbName);
var mapDbo = await mongoCollection.FindSync(e => e.Id == nameof(ServiceMap)).SingleOrDefaultAsync();
var services = mapDbo?.Services.Select(s =>
s.IsReachable
? MicrowaveServiceNode.ReachableMicrowaveServiceNode(s.ServiceEndPoint, s.Services)
: MicrowaveServiceNode.UnreachableMicrowaveServiceNode(s.ServiceEndPoint, s.Services));
return(mapDbo == null ? null : new ServiceMap(services));
}
public void GetNodesAndEdges()
{
var discoMock = new Mock <IDiscoveryHandler>();
var map = new ServiceMap(new List <MicrowaveServiceNode>
{
MicrowaveServiceNode.ReachableMicrowaveServiceNode(new ServiceEndPoint(new Uri("http://12.de"), "Name"),
new List <ServiceEndPoint>
{
new ServiceEndPoint(new Uri("http://123.de"), "Name"),
new ServiceEndPoint(new Uri("http://1234.de"), "Name")
}),
MicrowaveServiceNode.ReachableMicrowaveServiceNode(new ServiceEndPoint(new Uri("http://123.de"), "Name2"),
new List <ServiceEndPoint>
{
new ServiceEndPoint(new Uri("http://12.de"), "Name2"),
new ServiceEndPoint(new Uri("http://1234.de"), "Name")
}),
MicrowaveServiceNode.ReachableMicrowaveServiceNode(new ServiceEndPoint(new Uri("http://1234.de"), "MostFrequentService"),
new List <ServiceEndPoint>())
});
discoMock.Setup(m => m.GetServiceMap()).ReturnsAsync(map);
var serviceMapPage = new ServiceMapPage(discoMock.Object, null);
serviceMapPage.OnGetAsync().Wait();
var nodes = serviceMapPage.OrderedNodes.ToList();
Assert.AreEqual(3, nodes.Count);
Assert.AreEqual("http://1234.de/", nodes[0].serviceAddress);
Assert.AreEqual("MostFrequentService", nodes[0].label);
Assert.AreEqual("http://1234.de/", nodes[0].id);
Assert.AreEqual(0, nodes[0].x);
Assert.AreEqual(0, nodes[0].y);
Assert.AreEqual(new Uri("http://123.de"), nodes[1].serviceAddress);
Assert.AreEqual(new Uri("http://12.de"), nodes[2].serviceAddress);
Assert.AreEqual(0, nodes[2].x);
Assert.AreEqual(1, nodes[2].y);
var edges = serviceMapPage.Edges.ToList();
Assert.AreEqual(4, edges.Count);
Assert.AreEqual("http://12.de/", edges[0].source);
Assert.AreEqual("http://123.de/", edges[0].target);
Assert.AreEqual("http://12.de/", edges[1].source);
Assert.AreEqual("http://1234.de/", edges[1].target);
Assert.AreEqual("http://123.de/", edges[2].source);
Assert.AreEqual("http://12.de/", edges[2].target);
Assert.AreEqual("http://123.de/", edges[3].source);
Assert.AreEqual("http://1234.de/", edges[3].target);
}
public EventLocation(IEnumerable <EventsPublishedByService> allServices, EventsSubscribedByService eventsSubscribedByService)
{
var readModels = eventsSubscribedByService.ReadModelSubcriptions.ToList();
var handleAsyncEvents = eventsSubscribedByService.Events.ToList();
UnresolvedEventSubscriptions = handleAsyncEvents;
UnresolvedReadModeSubscriptions = readModels;
foreach (var service in allServices)
{
var relevantEventsOfService = handleAsyncEvents.Where(ev => service.PublishedEventTypes.Contains(ev)).ToList();
var relevantEvents = relevantEventsOfService.Select(relevantEvent =>
{
var notFoundProperties = GetDiffOfProperties(relevantEvent, service);
return(new EventSchema(relevantEvent.Name, notFoundProperties));
}).ToList();
var relevantReadModelsService = readModels.Where(r => service.PublishedEventTypes.Contains(r.GetsCreatedOn)).ToList();
var relevantReadModels = relevantReadModelsService.Select(readModel =>
{
var createdEvent = readModel.GetsCreatedOn;
var notFoundProperties = GetDiffOfProperties(createdEvent, service);
return(new ReadModelSubscription(
readModel.ReadModelName,
new EventSchema(createdEvent.Name, notFoundProperties)));
}).ToList();
if (!relevantEvents.Any() && !relevantReadModels.Any())
{
continue;
}
SetDomainEventLocation(MicrowaveServiceNode.Create(service.ServiceEndPoint,
relevantEvents,
relevantReadModels));
UnresolvedEventSubscriptions = UnresolvedEventSubscriptions.Except(relevantEvents);
UnresolvedReadModeSubscriptions = UnresolvedReadModeSubscriptions.Except(relevantReadModels);
}
}
public EventLocationFake() : base(new List <MicrowaveServiceNode>
{
MicrowaveServiceNode.Create(new ServiceEndPoint(new Uri("http://luls.de/")),
new List <EventSchema>
{
new EventSchema(nameof(Ev1))
}, new List <ReadModelSubscription>()),
MicrowaveServiceNode.Create(new ServiceEndPoint(new Uri("http://troll.de/")),
new List <EventSchema>
{
new EventSchema(nameof(Ev2))
}, new List <ReadModelSubscription>()),
MicrowaveServiceNode.Create(new ServiceEndPoint(new Uri("http://troll2.de/")),
new List <EventSchema>(),
new List <ReadModelSubscription>
{
new ReadModelSubscription(nameof(IdQuery), new EventSchema(nameof(Ev2)))
})
}, new List <EventSchema>(), new List <ReadModelSubscription>())
{
}
public async Task GetServiceDependencies()
{
var serviceNodeWithDependentServicesDto = MicrowaveServiceNode.ReachableMicrowaveServiceNode(new ServiceEndPoint(null, "ServiceName"),
new List <ServiceEndPoint>
{
new ServiceEndPoint(new Uri("http://remoteservice1.de"), "RemoteName1"),
new ServiceEndPoint(new Uri("http://remoteservice2.de"), "RemoteName2"),
});
var mockHttp = new MockHttpMessageHandler();
var serializeObject = JsonConvert.SerializeObject(serviceNodeWithDependentServicesDto);
mockHttp.When("http://localhost:5000/Dicovery/ServiceDependencies")
.Respond("application/json", serializeObject);
var client = new HttpClient(mockHttp);
client.BaseAddress = new Uri("http://localhost:5000/");
var mock = new Mock <IDiscoveryClientFactory>();
mock.Setup(m => m.GetClient(It.IsAny <Uri>())).ReturnsAsync(client);
var serviceDiscoveryRepository = new DiscoveryRepository(mock.Object, new MicrowaveLogger <DiscoveryRepository>());
var serviceAddress = new Uri("http://localhost:5000/");
var serviceNode = await serviceDiscoveryRepository.GetDependantServices(serviceAddress);
var dependantServices = serviceNode.ConnectedServices.ToList();
Assert.AreEqual(2, dependantServices.Count);
Assert.AreEqual("ServiceName", serviceNode.ServiceEndPoint.Name);
Assert.AreEqual(new Uri("http://localhost:5000/"), serviceNode.ServiceEndPoint.ServiceBaseAddress);
Assert.AreEqual("RemoteName1", dependantServices[0].Name);
Assert.AreEqual("RemoteName2", dependantServices[1].Name);
Assert.AreEqual(new Uri("http://remoteservice1.de"), dependantServices[0].ServiceBaseAddress);
Assert.AreEqual(new Uri("http://remoteservice2.de"), dependantServices[1].ServiceBaseAddress);
}
public async Task SaveAndLoadServiceMap(PersistenceLayerProvider layerProvider)
{
var statusRepository = layerProvider.StatusRepository;
var map = new ServiceMap(new List <MicrowaveServiceNode>
{
MicrowaveServiceNode.ReachableMicrowaveServiceNode(new ServiceEndPoint(new Uri("http://123.de"), "Name"),
new List <ServiceEndPoint>
{
new ServiceEndPoint(new Uri("http://www.uri1.de"), "Name")
}),
MicrowaveServiceNode.ReachableMicrowaveServiceNode(new ServiceEndPoint(new Uri("http://123.de"), "Name2"),
new List <ServiceEndPoint>
{
new ServiceEndPoint(new Uri("http://www.uri2.de"), "Name2"),
new ServiceEndPoint(new Uri("http://www.uri1.de"), "Name")
}),
MicrowaveServiceNode.UnreachableMicrowaveServiceNode(new ServiceEndPoint(new Uri("http://123.de")),
new List <ServiceEndPoint>())
});
await statusRepository.SaveServiceMap(map);
var mapLoaded = await statusRepository.GetServiceMap();
var serviceDependenciesDtos = mapLoaded.AllServices.ToList();
Assert.AreEqual("Name", serviceDependenciesDtos[0].ServiceEndPoint.Name);
Assert.AreEqual("Name2", serviceDependenciesDtos[1].ServiceEndPoint.Name);
Assert.IsTrue(serviceDependenciesDtos[1].IsReachable);
Assert.IsFalse(serviceDependenciesDtos[2].IsReachable);
Assert.AreEqual(new Uri("http://www.uri1.de"), serviceDependenciesDtos[0].ConnectedServices.First().ServiceBaseAddress);
Assert.AreEqual(new Uri("http://www.uri2.de"), serviceDependenciesDtos[1].ConnectedServices.First().ServiceBaseAddress);
Assert.AreEqual(new Uri("http://www.uri1.de"), serviceDependenciesDtos[1].ConnectedServices.Skip(1).First().ServiceBaseAddress);
Assert.AreEqual("Name", serviceDependenciesDtos[0].ConnectedServices.First().Name);
Assert.AreEqual("Name2", serviceDependenciesDtos[1].ConnectedServices.First().Name);
Assert.AreEqual("Name", serviceDependenciesDtos[1].ConnectedServices.Skip(1).First().Name);
}
public async Task <EventLocation> GetEventLocation()
{
if (_cache.HasValue)
{
return(_cache.GetValue());
}
var mongoCollection = _database.GetCollection <EventLocationDbo>(StatusDbName);
var location = await mongoCollection.FindSync(e => e.Id == nameof(EventLocation)).SingleOrDefaultAsync();
return(location == null?EventLocation.Default() : new EventLocation(location.Services.Select(s =>
MicrowaveServiceNode.Create(s.ServiceEndPoint, s.SubscribedEvents, s.ReadModels)), location
.UnresolvedEventSubscriptions, location.UnresolvedReadModeSubscriptions));
}
