public static ContainerBuilder AddNodeMonitorService(this ContainerBuilder builder,
IConfiguration configuration)
{
builder.Register(c =>
{
var nodeMonitorConfigurationOptions = new NodeMonitorConfigurationOptions();
configuration.Bind(NodeMonitorConfigurationOptions.ConfigurationSectionName,
nodeMonitorConfigurationOptions);
var nodeMonitorProvider =
new NodeMonitor(nodeMonitorConfigurationOptions, c.Resolve <Serilog.ILogger>());
return(nodeMonitorProvider);
}).As <INodeMonitor>().InstancePerLifetimeScope();
builder.RegisterType <NodeMonitorService>().As <IHostedService>();
return(builder);
}
public NodeMonitor(NodeMonitorConfigurationOptions configuration, ILogger logger)
{
_logger = logger.ForContext("SourceContext", nameof(NodeMonitor));
_configuration = configuration;
if (_configuration.Enabled)
{
try
{
var ipAddress = IPAddress.Parse(_configuration.Tester.Listening);
_endPoint = new IPEndPoint(ipAddress, _configuration.Tester.Port);
_client = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
}
catch (Exception ex)
{
_logger.Here().Error(ex, "Cannot initialize node monitor service");
}
}
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
/// <param name="configuration"></param>
/// <returns></returns>
public static ContainerBuilder AddSerfProcessService(this ContainerBuilder builder,
IConfiguration configuration)
{
// Do not start Serf when NodeMonitor is active
var nodeMonitorConfigurationOptions = new NodeMonitorConfigurationOptions();
configuration.Bind(NodeMonitorConfigurationOptions.ConfigurationSectionName,
nodeMonitorConfigurationOptions);
builder.Register(c =>
{
ISerfService serfService = null;
var logger = c.Resolve <Serilog.ILogger>();
try
{
var ct = new CancellationTokenSource();
var localNode = c.Resolve <ILocalNode>();
var signing = c.Resolve <ISigning>();
var lifetime = c.Resolve <IHostApplicationLifetime>();
var serfClient = c.Resolve <ISerfClient>();
serfService = nodeMonitorConfigurationOptions.Enabled
? new SerfServiceTester(serfClient, signing, logger)
: new SerfService(serfClient, signing, logger);
serfService.StartAsync(lifetime).GetAwaiter();
if (serfService.Disabled)
{
return(serfService);
}
ct.CancelAfter(100000);
while (!ct.IsCancellationRequested && !serfClient.ProcessStarted)
{
Task.Delay(100, ct.Token);
}
var tcpSession = serfClient.TcpSessionsAddOrUpdate(
new TcpSession(serfClient.SerfConfigurationOptions.Listening).Connect(serfClient
.SerfConfigurationOptions.RPC));
var connectResult = serfClient.Connect(tcpSession.SessionId).GetAwaiter().GetResult();
if (connectResult.Success)
{
var seedNodesSection = configuration.GetSection("SeedNodes").GetChildren().ToList();
if (!seedNodesSection.Any())
{
return(serfService);
}
var seedNodes = new SeedNode(seedNodesSection.Select(x => x.Value));
serfService.JoinSeedNodes(seedNodes).GetAwaiter();
}
else
{
logger.Here().Error("{@Error}", ((SerfError)connectResult.NonSuccessMessage).Error);
}
localNode.Ready();
}
catch (TaskCanceledException ex)
{
logger.Here().Error(ex, "Starting serf timeout error");
}
catch (OperationCanceledException ex)
{
logger.Here().Error(ex, "Starting serf operation canceled error");
}
catch (Exception ex)
{
logger.Here().Error(ex, "Starting serf error");
}
return(serfService);
}).As <IStartable>().SingleInstance();
return(builder);
}
