private async Task NetworkDiscovery()
{
var nodesActive = _nodesRepository.GetNodes(NodesRepositoryFilter.OnlyActive).ToList();
var nodesActiveWithoutSelf = nodesActive.Where(n => !n.Contains(_nodeOptions.Value.Self)).ToList();
if (nodesActive.Count == nodesActiveWithoutSelf.Count)
{
nodesActive.Add(_nodeOptions.Value.Self);
}
var tasks = nodesActiveWithoutSelf.Select(async(nodeUrl) =>
{
var timer = DateTimeOffset.Now.ToUnixTimeSeconds();
var result = await _peerCommunicationService.GetAsync <InformationNodes>(nodeUrl, Endpoints.Information + "/nodes");
var timespan = DateTimeOffset.Now.ToUnixTimeSeconds() - timer;
ProcessResult(nodeUrl, result, timespan);
if (result != null && result.Nodes != null && !result.Nodes.Contains(_nodeOptions.Value.Self))
{
await _peerCommunicationService.SendAsync(
nodesActiveWithoutSelf,
Endpoints.Information + "/nodes",
new InformationNodesAdd()
{
Nodes = nodesActive
});
}
});
await Task.WhenAll(tasks);
}
public async Task <IActionResult> PostAsync([FromBody] EncryptedMessage message)
{
_logger.LogInformation("Got message at endpoint api/messages from {0}:{1}", HttpContext.Connection.RemoteIpAddress, HttpContext.Connection.RemotePort);
var result = _messageStore.TryAddAsync(message);
if (!result.Result)
{
return(BadRequest());
}
await _internalMessageManager.SendAsync(message);
await _peerCommunicationService.SendAsync(Endpoints.Messages, message);
return(Ok());
}
private async Task ReceiveInternalMessageAsync(IWebSocketConnection webSocketConnection, ClientInternalMessage clientInternalMessage)
{
_logger.LogInformation("Received internal message to {0}", clientInternalMessage.To);
GetConnections(clientInternalMessage.To).ToList().ForEach(id =>
{
_logger.LogInformation("-Active connection for reciever: {0}", id);
});
_logger.LogInformation("-No more active connections for reciever");
var connectionId = webSocketConnection.ConnectionId;
var from = _mapConnectionsToPublicKey.Where(m => m.Key == connectionId).Select(m => m.Value).SingleOrDefault();
var message = _messageBuilder.AddContent(clientInternalMessage.Content)
.AddReciever(clientInternalMessage.To)
.AddSender(from)
.AddTitle(clientInternalMessage.Title)
.AddContent(clientInternalMessage.Content)
.EncryptAndBuild(GetPrivateKeyFromConnectionId(connectionId));
var added = _messageStore.TryAddAsync(message);
if (!added.Result)
{
throw new InvalidOperationException();
}
var internalMessage = _mapper.Map <InternalMessage>(clientInternalMessage);
internalMessage.From = from;
internalMessage.DateTime = DateTimeOffset.FromUnixTimeSeconds(message.Timestamp).ToString();
internalMessage.Timestamp = message.Timestamp;
internalMessage.Id = message.Id.GetHashCode().ToString();
await SendAsync(internalMessage, connectionId);
await SendConfirmationToSender(webSocketConnection, clientInternalMessage, internalMessage);
await _peerCommunicationService.SendAsync(Endpoints.Messages, message);
}
private async Task SendNewBlockAsync(Block createdBlock)
{
var nodes = _nodesRepository.GetNodes(NodesRepositoryFilter.OnlyActive);
await _peerCommunicationService.SendAsync(nodes, Endpoints.Blockchain, createdBlock);
}