public async Task RelayXServerAsync(ServerNodeData newServer, List <ServerNodeData> activeXServers, CancellationToken cancellationToken)
{
ServerRegisterRequest registerRequest = new ServerRegisterRequest()
{
ProfileName = newServer.ProfileName,
NetworkAddress = newServer.NetworkAddress,
NetworkPort = newServer.NetworkPort,
NetworkProtocol = newServer.NetworkProtocol,
Signature = newServer.Signature,
Tier = newServer.Tier,
FeeAddress = newServer.FeeAddress,
KeyAddress = newServer.KeyAddress,
SignAddress = newServer.SignAddress
};
foreach (var activeServer in activeXServers)
{
string xServerURL = networkFeatures.GetServerUrl(activeServer.NetworkProtocol, activeServer.NetworkAddress, activeServer.NetworkPort);
var client = new RestClient(xServerURL);
var registerRestRequest = new RestRequest("/registerserver", Method.POST);
var request = JsonConvert.SerializeObject(registerRequest);
registerRestRequest.AddParameter("application/json; charset=utf-8", request, ParameterType.RequestBody);
registerRestRequest.RequestFormat = DataFormat.Json;
var result = await client.ExecuteAsync(registerRestRequest, cancellationToken);
}
}
private async Task <ServerNodeData> ServerCheck(ServerNodeData serverNode)
{
var serverCheck = await networkFeatures.Register(serverNode, serverCheckOnly : true);
if (serverCheck.Success)
{
serverNode.Active = true;
serverNode.LastSeen = DateTime.UtcNow;
}
else
{
serverNode.Active = false;
}
return(serverNode);
}
public async Task <IActionResult> RegisterServerAsync([FromBody] ServerRegisterRequest registerRequest)
{
xServer.Stats.IncrementPublicRequest();
ServerNodeData serverNode = new ServerNodeData()
{
ProfileName = registerRequest.ProfileName,
NetworkAddress = registerRequest.NetworkAddress,
NetworkPort = registerRequest.NetworkPort,
KeyAddress = registerRequest.KeyAddress,
SignAddress = registerRequest.SignAddress,
FeeAddress = registerRequest.FeeAddress,
Signature = registerRequest.Signature,
Tier = registerRequest.Tier,
NetworkProtocol = registerRequest.NetworkProtocol
};
RegisterResult registerResult = await xServer.Register(serverNode);
return(Json(registerResult));
}
/// <summary>
/// Return xServer from profile name or sign address.
/// </summary>
/// <param name="profileName">The profile name to search for the xserver</param>
/// <param name="signAddress">The sign address to search for the xserver</param>
/// <returns>xServer found by the search.</returns>
public ServerRegisterResult SearchForXServer(string profileName = "", string signAddress = "")
{
ServerRegisterResult result = new ServerRegisterResult();
using (X42DbContext dbContext = new X42DbContext(ConnectionString))
{
ServerNodeData serverNode = null;
if (!string.IsNullOrEmpty(profileName))
{
serverNode = dbContext.ServerNodes.Where(sn => sn.ProfileName == profileName).FirstOrDefault();
}
else if (!string.IsNullOrEmpty(profileName))
{
serverNode = dbContext.ServerNodes.Where(sn => sn.SignAddress == signAddress).FirstOrDefault();
}
if (serverNode != null)
{
result = new ServerRegisterResult()
{
Id = serverNode.Id,
ProfileName = serverNode.ProfileName,
NetworkProtocol = serverNode.NetworkProtocol,
NetworkAddress = serverNode.NetworkAddress,
NetworkPort = serverNode.NetworkPort,
Signature = serverNode.Signature,
Tier = serverNode.Tier,
FeeAddress = serverNode.FeeAddress,
KeyAddress = serverNode.KeyAddress,
SignAddress = serverNode.SignAddress
};
}
}
return(result);
}
private async Task <List <string> > LocateAndAddNewServers(CancellationToken cancellationToken)
{
List <string> result = new List <string>();
using (X42DbContext dbContext = new X42DbContext(databaseSettings.ConnectionString))
{
List <ServerNodeData> serverNodes = dbContext.ServerNodes.Where(s => s.Active).ToList();
string selfProfile = networkFeatures.GetServerProfile();
int localActiveCount = serverNodes.Count();
var xServerStats = await networkFeatures.GetXServerStats();
if (xServerStats == null)
{
return(result);
}
foreach (var connectedXServer in xServerStats.Nodes)
{
var xServer = serverNodes.Where(x => x.NetworkAddress == connectedXServer.NetworkAddress);
if (xServer.Count() == 0)
{
serverNodes.Add(new ServerNodeData()
{
NetworkAddress = connectedXServer.NetworkAddress,
NetworkPort = connectedXServer.NetworkPort,
NetworkProtocol = connectedXServer.NetworkProtocol
});
}
}
if (serverNodes.Count() > 0)
{
List <ServerNodeData> newserverNodes = new List <ServerNodeData>();
foreach (ServerNodeData server in serverNodes)
{
bool foundSelf = false;
bool xServerSyncComplete = false;
long lastId = 0;
try
{
string xServerURL = networkFeatures.GetServerUrl(server.NetworkProtocol, server.NetworkAddress, server.NetworkPort);
while (!xServerSyncComplete)
{
try
{
var client = new RestClient(xServerURL);
var allActiveXServersRequest = new RestRequest("/getactivexservers/", Method.GET);
allActiveXServersRequest.AddParameter("fromId", lastId);
var allActiveXServersResult = await client.ExecuteAsync <List <ServerRegisterResult> >(allActiveXServersRequest, cancellationToken).ConfigureAwait(false);
if (allActiveXServersResult.StatusCode == HttpStatusCode.OK)
{
var activeXServersList = allActiveXServersResult.Data;
if (activeXServersList.Count() == 0)
{
xServerSyncComplete = true;
}
else
{
foreach (var serverResult in activeXServersList)
{
if (serverResult.Id > lastId)
{
lastId = serverResult.Id;
}
if (serverResult.ProfileName == selfProfile)
{
foundSelf = true;
}
var registeredServer = serverNodes.Where(s => s.Signature == serverResult.Signature).FirstOrDefault();
if (registeredServer == null)
{
var newServer = new ServerNodeData()
{
ProfileName = serverResult.ProfileName,
NetworkAddress = serverResult.NetworkAddress,
NetworkPort = serverResult.NetworkPort,
NetworkProtocol = serverResult.NetworkProtocol,
Signature = serverResult.Signature,
Tier = serverResult.Tier,
FeeAddress = serverResult.FeeAddress,
SignAddress = serverResult.SignAddress,
KeyAddress = serverResult.KeyAddress,
Active = true,
DateAdded = DateTime.UtcNow,
LastSeen = DateTime.UtcNow,
Priority = 0,
Relayed = true
};
// Local Registration of new nodes we don't know about.
await networkFeatures.Register(newServer);
}
}
}
}
else
{
xServerSyncComplete = true;
}
}
catch (Exception ex)
{
logger.LogDebug($"Server failed to request during reco", ex);
}
}
if (!foundSelf)
{
result.Add(xServerURL);
}
}
catch (Exception ex)
{
logger.LogDebug($"Error in Reconciliation Service", ex);
}
}
}
}
return(result);
}
