protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
_logger.LogInformation("Starting utility network updated event consumer worker at: {time}", DateTimeOffset.Now);
try
{
if (String.IsNullOrEmpty(_kafkaSetting.UtilityNetworkNotificationsTopic))
{
throw new ApplicationException("UtilityNetworkNotificationsTopic Kafka app setting must be set!");
}
_kafkaConsumer = _eventDispatcher.Config("utility_network_updated_event_" + Guid.NewGuid(), c => {
var kafkaConfig = c.UseKafka(_kafkaSetting.Server);
if (_kafkaSetting.CertificateFilename != null)
{
kafkaConfig.WithCertificate(_kafkaSetting.CertificateFilename);
}
})
.Logging(l => l.UseSerilog())
.Positions(x =>
{
x.SetInitialPosition(StartFromPosition.Now);
x.StoreInMemory();
})
.Topics(t => t.Subscribe(_kafkaSetting.UtilityNetworkNotificationsTopic))
.Start();
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
await Task.CompletedTask;
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
_logger.LogInformation("Event consumer started at: {time}", DateTimeOffset.Now);
_consumer = _eventDispatcher.Config(_topicName + "-", c => c.UseKafka(_kafkaServer))
.Logging(l => l.UseSerilog())
.Positions(p => p.StoreInMemory(_positionsStorage))
.Topics(t => t.Subscribe(_topicName))
.Start();
stoppingToken.Register(() =>
_logger.LogDebug($"Event consumer is stopping.."));
while (!stoppingToken.IsCancellationRequested)
{
await Task.Delay(1000, stoppingToken);
}
_logger.LogDebug($"Event consumer is stopping...");
}
public void SubscribeRouteNetwork()
{
int incremantalId = 0;
var serilogLogger = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var loggerFactory = (ILoggerFactory) new LoggerFactory();
loggerFactory.AddSerilog(serilogLogger);
_eventDispatcher = new ToposTypedEventObservable <RouteNetworkEditOperationOccuredEvent>(loggerFactory.CreateLogger <ToposTypedEventMediator <RouteNetworkEditOperationOccuredEvent> >());
var kafkaConsumer = _eventDispatcher.Config("route_network_event_" + Guid.NewGuid(), c => c.UseKafka("20.73.229.67:9094")
.WithCertificate("/home/mihai/Certificates/kafka-aura-prod.crt"))
.Positions(p => p.StoreInMemory(new InMemPositionsStorage()))
.Topics(t => t.Subscribe("domain.route-network"))
.Handle(async(messages, context, token) =>
{
foreach (var message in messages)
{
if (message.Body is RouteNetworkEditOperationOccuredEvent)
{
var route = (RouteNetworkEditOperationOccuredEvent)message.Body;
if (route.RouteNetworkCommands != null)
{
foreach (var command in route.RouteNetworkCommands)
{
if (command.RouteNetworkEvents != null)
{
foreach (var routeNetworkEvent in command.RouteNetworkEvents)
{
try
{
switch (routeNetworkEvent)
{
case RouteNodeAdded domainEvent:
incremantalId++;
if (domainEvent.NamingInfo.Name != null)
{
var node = new RouteNode
{
id = domainEvent.NodeId,
incrementalId = incremantalId,
name = domainEvent.NamingInfo.Name,
coordinates = domainEvent.Geometry
};
if (node != null)
{
await addRouteNode(node);
}
}
break;
case RouteNodeMarkedForDeletion domainEvent:
await DeleteRouteNode(domainEvent.NodeId);
break;
case RouteNodeGeometryModified domainEvent:
await UpdateGeometryNode(domainEvent.NodeId, domainEvent.Geometry);
break;
case OpenFTTH.Events.Core.NamingInfoModified domainEvent:
await UpdateNameNode(domainEvent.EventId, domainEvent.NamingInfo.Name);
break;
}
}
catch (System.NullReferenceException e)
{
_logger.LogInformation("exception caught");
}
}
}
}
}
}
}
}).Start();
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
_logger.LogInformation("Starting route network event consumer worker at: {time}", DateTimeOffset.Now);
try
{
if (String.IsNullOrEmpty(_kafkaSetting.RouteNetworkEventTopic))
{
throw new ApplicationException("RouteNetworkEventTopic Kafka app setting must be set!");
}
var toposConfig = _eventDispatcher.Config("route_network_event_" + Guid.NewGuid(), c => {
var kafkaConfig = c.UseKafka(_kafkaSetting.Server);
if (_kafkaSetting.CertificateFilename != null)
{
kafkaConfig.WithCertificate(_kafkaSetting.CertificateFilename);
}
})
.Logging(l => l.UseSerilog())
.Positions(p => p.StoreInMemory(_positionsStorage))
.Topics(t => t.Subscribe(_kafkaSetting.RouteNetworkEventTopic));
_eventDispatcher.OnEvent.Subscribe(_routeNetworkEventHandler);
_kafkaConsumer = toposConfig.Start();
var inMemRouteNetworkState = (InMemRouteNetworkState)_routeNetworkState;
// Wait for load mode to create an initial version/state
_logger.LogInformation("Starting route network events load mode...");
bool loadFinish = false;
if (loadFinish)
{
_logger.LogError("NOTICE THAT WAITING FOR ROUTE EVENTS LOADING IS DISABLED!!!");
}
while (!stoppingToken.IsCancellationRequested && !loadFinish)
{
_logger.LogDebug("Waiting for load mode to finish creating initial state...");
_logger.LogInformation($"{inMemRouteNetworkState.NumberOfObjectsLoaded} route network Kafka events processed.");
DateTime waitStartTimestamp = DateTime.UtcNow;
await Task.Delay(5000, stoppingToken);
TimeSpan timespan = waitStartTimestamp - inMemRouteNetworkState.LastEventRecievedTimestamp;
if (timespan.TotalSeconds > 20)
{
loadFinish = true;
}
}
((InMemRouteNetworkState)_routeNetworkState).FinishLoadMode();
_logger.LogInformation("Loading of initial route network state finished.");
// Dehydrate projections
LogMenUsage();
_logger.LogInformation("Start dehydrate in-memory projections...");
_eventStore.DehydrateProjections();
_logger.LogInformation("Finish dehydrating in-memory projections.");
LogMenUsage();
// We are now ready to serve the public if the loaded objects are bigger than 0
if (inMemRouteNetworkState.NumberOfObjectsLoaded > 0)
{
File.Create("/tmp/healthy");
_logger.LogInformation("Healhty file written writen to tmp.");
}
else
{
throw new ApplicationException("Recieved no route network elements from Kafka topic.");
}
// Start conversion
new ConversionRunner(_loggerFactory, _eventStore, _geoDatabaseSetting, _commandDispatcher, _queryDispatcher).Run();
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
await Task.CompletedTask;
}
