/// <summary>
///
/// </summary>
/// <param name="seedNode"></param>
public async Task <bool> JoinSeedNodes(SeedNode seedNode)
{
try
{
var tcpSession = _serfClient.GetTcpSession(_tcpSession.SessionId);
if (!tcpSession.Ready)
{
tcpSession = tcpSession.Connect(_serfClient.SerfConfigurationOptions.RPC);
await _serfClient.Connect(tcpSession.SessionId);
}
var joinResult = await _serfClient.Join(seedNode.Seeds, tcpSession.SessionId);
if (!joinResult.Success)
{
_logger.Here().Error(((SerfError)joinResult.NonSuccessMessage).Error);
return(false);
}
JoinedSeedNodes = true;
_serfClient.SeedNodes.Seeds.AddRange(seedNode.Seeds);
_logger.Here().Information("Serf might still be trying to join the seed nodes. Number of nodes joined: {@NumPeers}", joinResult.Value.Peers.ToString());
return(true);
}
catch (Exception ex)
{
_logger.Here().Fatal(ex, $"Unable to create Serf RPC address");
return(false);
}
}
public async Task <bool> JoinSeedNodes(SeedNode seedNode)
{
_logger.Here().Debug("Joining seed nodes");
foreach (var node in seedNode.Seeds)
{
_logger.Here().Information("Joining seed node {@Node}", node);
}
// TODO: testable configuration, e.g. delays, never-ending connection attempts, etc.
return(true);
}
public ActionResult AddNode(string label, string ip, int?port)
{
if (port != null)
{
SeedNode newNode = new SeedNode()
{
Coin = nodeService.Coin,
IP = ip,
Label = label,
Port = Convert.ToInt32(port),
Enabled = true,
};
using (var db = new CoinpanicContext())
{
db.SeedNodes.Add(newNode);
db.SaveChanges();
}
}
return(RedirectToAction("Index"));
}
/// <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);
}
