/// <summary>
/// Handle the request for GetPeerInfo
/// </summary>
/// <param name="getPeerInfoRequest">The request</param>
/// <param name="channelHandlerContext">The channel handler context</param>
/// <param name="senderPeerId">The sender peer identifier</param>
/// <param name="correlationId">The correlationId</param>
/// <returns>The GetPeerInfoResponse</returns>
protected override GetPeerInfoResponse HandleRequest(GetPeerInfoRequest getPeerInfoRequest,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
Guard.Argument(getPeerInfoRequest, nameof(getPeerInfoRequest)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerId, nameof(senderPeerId)).NotNull();
Logger.Debug("received message of type GetPeerInfoRequest");
var ip = getPeerInfoRequest.Ip;
var peerInfo = _peerRepository.GetPeersByIpAndPublicKey(ip, getPeerInfoRequest.PublicKey)
.Select(x =>
new PeerInfo
{
PeerId = x.PeerId,
Reputation = x.Reputation,
IsBlacklisted = x.BlackListed,
IsUnreachable = x.IsAwolPeer,
InactiveFor = x.InactiveFor.ToDuration(),
LastSeen = x.LastSeen.ToTimestamp(),
Modified = x.Modified?.ToTimestamp(),
Created = x.Created.ToTimestamp()
}).ToList();
var response = new GetPeerInfoResponse();
response.PeerInfo.AddRange(peerInfo);
return(response);
}
public async Task RunAsync(CancellationToken ct)
{
_logger.Information("Starting the Catalyst Node");
_logger.Information($"***** using PublicKey: {_publicKey.Bytes.ToBase32()} *****");
await StartSocketsAsync().ConfigureAwait(false);
_dfsService.StartAsync().ConfigureAwait(false);
_synchronizer.StartAsync().ConfigureAwait(false);
_synchronizer.SyncCompleted.Subscribe((x) =>
{
var currentPoaNode = _peerRepository.GetPeersByIpAndPublicKey(_peerSettings.PeerId.Ip, _peerSettings.PeerId.PublicKey).FirstOrDefault();
if (currentPoaNode == null)
{
_logger.Information($"Current node with IP address '{_peerSettings.PeerId.Ip}' is not found in poa node list. So this node will not take part in consensus.");
}
else
{
Consensus.StartProducing();
}
});
bool exit;
do
{
await Task.Delay(300, ct); //just to get the exit message at the bottom
_logger.Debug("Type 'exit' to exit, anything else to continue");
exit = string.Equals(Console.ReadLine(), "exit", StringComparison.OrdinalIgnoreCase);
} while (!ct.IsCancellationRequested);
_logger.Debug("Stopping the Catalyst Node");
}
public override void HandleBroadcast(IObserverDto <ProtocolMessage> messageDto)
{
if (!_syncState.IsSynchronized)
{
return;
}
try
{
Logger.Verbose("received {message} from {port}", messageDto.Payload.CorrelationId.ToCorrelationId(),
messageDto.Payload.PeerId.Port);
// @TODO here we use the protobuff message to parse rather than using the CandidateDeltaBroadcastDao
/////////////////////////////////////////////////////////////////////////////////////////////////
var deserialized = messageDto.Payload.FromProtocolMessage <CandidateDeltaBroadcast>();
var previousDeltaDfsHashCid = deserialized.PreviousDeltaDfsHash.ToByteArray().ToCid();
/////////////////////////////////////////////////////////////////////////////////////////////////
if (!_hashProvider.IsValidHash(previousDeltaDfsHashCid.Hash.ToArray()))
{
Logger.Error("PreviousDeltaDfsHash is not a valid hash");
return;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
var hashCid = deserialized.Hash.ToByteArray().ToCid();
/////////////////////////////////////////////////////////////////////////////////////////////////
if (!_hashProvider.IsValidHash(hashCid.Hash.ToArray()))
{
Logger.Error("Hash is not a valid hash");
return;
}
var messagePoaNode = _peerRepository.GetPeersByIpAndPublicKey(messageDto.Payload.PeerId.Ip, messageDto.Payload.PeerId.PublicKey).FirstOrDefault();
if (messagePoaNode == null)
{
Logger.Error($"Message from IP address '{messageDto.Payload.PeerId.Ip}' with public key '{messageDto.Payload.PeerId.PublicKey}' is not found in producer node list.");
return;
}
if (deserialized.IsValid())
{
_deltaVoter.OnNext(deserialized);
}
}
catch (Exception exception)
{
Logger.Error(exception,
$"Failed to process candidate delta broadcast {messageDto.Payload.ToJsonString()}.");
}
}
public void HandleBroadcast_Should_Cast_Hashes_To_Multihash_And_Try_Update()
{
var newHash = _hashProvider.ComputeUtf8MultiHash("newHash").ToCid();
var prevHash = _hashProvider.ComputeUtf8MultiHash("prevHash").ToCid();
var receivedMessage = PrepareReceivedMessage(newHash.ToArray(), prevHash.ToArray());
_peerRepository.GetPeersByIpAndPublicKey(receivedMessage.Payload.PeerId.Ip, receivedMessage.Payload.PeerId.PublicKey).Returns(new List <Peer>()
{
new Peer()
});
var deltaDfsHashObserver = new DeltaDfsHashObserver(_deltaHashProvider, _syncState, _peerRepository, _logger);
deltaDfsHashObserver.HandleBroadcast(receivedMessage);
_deltaHashProvider.Received(1).TryUpdateLatestHash(prevHash, newHash);
}
public override void HandleBroadcast(IObserverDto <ProtocolMessage> messageDto)
{
if (!_syncState.IsSynchronized)
{
return;
}
try
{
var deserialized = messageDto.Payload.FromProtocolMessage <FavouriteDeltaBroadcast>();
var previousDeltaDfsHashCid = deserialized.Candidate.PreviousDeltaDfsHash.ToByteArray().ToCid();
if (!_hashProvider.IsValidHash(previousDeltaDfsHashCid.Hash.ToArray()))
{
Logger.Error("PreviousDeltaDfsHash is not a valid hash");
return;
}
var hashCid = deserialized.Candidate.Hash.ToByteArray().ToCid();
if (!_hashProvider.IsValidHash(hashCid.Hash.ToArray()))
{
Logger.Error("Hash is not a valid hash");
return;
}
var messagePoaNode = _peerRepository.GetPeersByIpAndPublicKey(messageDto.Payload.PeerId.Ip, messageDto.Payload.PeerId.PublicKey).FirstOrDefault();
if (messagePoaNode == null)
{
Logger.Error($"Message from IP address '{messageDto.Payload.PeerId.Ip}' with public key '{messageDto.Payload.PeerId.PublicKey}' is not found in producer node list.");
return;
}
deserialized.IsValid();
_deltaElector.OnNext(deserialized);
}
catch (Exception exception)
{
Logger.Error(exception,
$"Failed to process favourite delta broadcast {messageDto.Payload.ToJsonString()}.");
}
}
public override void HandleBroadcast(IObserverDto <ProtocolMessage> messageDto)
{
if (!_syncState.IsSynchronized)
{
return;
}
try
{
var deserialised = messageDto.Payload.FromProtocolMessage <DeltaDfsHashBroadcast>();
var previousHash = deserialised.PreviousDeltaDfsHash.ToByteArray().ToCid();
if (previousHash == null)
{
Logger.Error("PreviousDeltaDfsHash is not a valid hash");
return;
}
var newHash = deserialised.DeltaDfsHash.ToByteArray().ToCid();
if (newHash == null)
{
Logger.Error("DeltaDfsHash is not a valid hash");
return;
}
var messagePoaNode = _peerRepository.GetPeersByIpAndPublicKey(messageDto.Payload.PeerId.Ip, messageDto.Payload.PeerId.PublicKey).FirstOrDefault();
if (messagePoaNode == null)
{
Logger.Error($"Message from IP address '{messageDto.Payload.PeerId.Ip}' with public key '{messageDto.Payload.PeerId.PublicKey}' is not found in producer node list.");
return;
}
_deltaHashProvider.TryUpdateLatestHash(previousHash, newHash);
}
catch (Exception exception)
{
Logger.Error(exception, "Failed to update latest delta hash from incoming broadcast message.");
}
}