public override void HandleBroadcast(IObserverDto <ProtocolMessage> messageDto)
{
try
{
var deserialised = messageDto.Payload.FromProtocolMessage <DeltaDfsHashBroadcast>();
var previousHash = _hashProvider.Cast(deserialised.PreviousDeltaDfsHash.ToByteArray());
if (previousHash == null)
{
Logger.Error($"PreviousDeltaDfsHash is not a valid hash");
return;
}
var newHash = _hashProvider.Cast(deserialised.DeltaDfsHash.ToByteArray());
if (newHash == null)
{
Logger.Error($"DeltaDfsHash is not a valid hash");
return;
}
_deltaHashProvider.TryUpdateLatestHash(previousHash, newHash);
}
catch (Exception exception)
{
Logger.Error(exception, "Failed to update latest delta hash from incoming broadcast message.");
}
}
public override void OnNext(IObserverDto <ProtocolMessage> messageDto)
{
Logger.Verbose("Pre Handle Message Called");
try
{
var correlationId = messageDto.Payload.CorrelationId.ToCorrelationId();
var recipientPeerId = messageDto.Payload.PeerId;
var response = HandleRequest(messageDto.Payload.FromProtocolMessage <TProtoReq>(),
messageDto.Context,
recipientPeerId,
correlationId);
var responseDto = new MessageDto(
response.ToProtocolMessage(PeerSettings.PeerId, correlationId),
recipientPeerId);
messageDto.Context.Channel.WriteAndFlushAsync(responseDto);
}
catch (Exception exception)
{
Logger.Error(exception, "Failed to process message");
}
}
public override void HandleBroadcast(IObserverDto <ProtocolMessage> messageDto)
{
try
{
Logger.Verbose("received {message} from {port}", messageDto.Payload.CorrelationId.ToCorrelationId(),
messageDto.Payload.PeerId.Port);
var deserialised = messageDto.Payload.FromProtocolMessage <CandidateDeltaBroadcast>();
if (!_hashProvider.IsValidHash(deserialised.PreviousDeltaDfsHash.ToByteArray()))
{
Logger.Error($"PreviousDeltaDfsHash is not a valid hash");
return;
}
if (!_hashProvider.IsValidHash(deserialised.Hash.ToByteArray()))
{
Logger.Error($"Hash is not a valid hash");
return;
}
deserialised.IsValid();
_deltaVoter.OnNext(deserialised);
}
catch (Exception exception)
{
Logger.Error(exception, $"Failed to process candidate delta broadcast {messageDto.Payload.ToJsonString()}.");
}
}
public override void HandleBroadcast(IObserverDto <ProtocolMessage> messageDto)
{
try
{
var deserialised = messageDto.Payload.FromProtocolMessage <FavouriteDeltaBroadcast>();
if (!_hashProvider.IsValidHash(deserialised.Candidate.PreviousDeltaDfsHash.ToByteArray()))
{
Logger.Error($"PreviousDeltaDfsHash is not a valid hash");
return;
}
if (!_hashProvider.IsValidHash(deserialised.Candidate.Hash.ToByteArray()))
{
Logger.Error($"Hash is not a valid hash");
return;
}
deserialised.IsValid();
_deltaElector.OnNext(deserialised);
}
catch (Exception exception)
{
Logger.Error(exception, $"Failed to process favourite delta broadcast {messageDto.Payload.ToJsonString()}.");
}
}
public override void HandleBroadcast(IObserverDto <ProtocolMessage> messageDto)
{
var count = Interlocked.Increment(ref _counter);
if (count % 2 == 0)
{
throw new ArgumentException("something went wrong handling the request");
}
}
public void OnNext(IObserverDto <ProtocolMessage> value)
{
if (value == NullObjects.ObserverDto)
{
return;
}
_logger.Debug($"observer {Index} received message of type {value?.Payload?.TypeUrl ?? "(null)"}");
_received.Push(value);
}
public override void HandleBroadcast(IObserverDto <ProtocolMessage> messageDto)
{
Logger.Debug("received broadcast");
var deserialised = messageDto.Payload.FromProtocolMessage <TransactionBroadcast>();
_transactionReceivedEvent.OnTransactionReceived(messageDto.Payload);
Logger.Debug("transaction signature is {0}", deserialised.PublicEntry.Signature);
}
public override void OnNext(IObserverDto <ProtocolMessage> messageDto)
{
try
{
HandleBroadcast(messageDto);
}
catch (Exception exception)
{
Logger.Error(exception, "Failed to handle message");
}
}
public override void OnNext(IObserverDto <ProtocolMessage> messageDto)
{
base.OnNext(messageDto);
var correlationId = messageDto.Payload.CorrelationId.ToCorrelationId();
if (_fileTransferFactory.GetFileTransferInformation(correlationId) != null)
{
_fileTransferFactory.FileTransferAsync(correlationId, CancellationToken.None).ConfigureAwait(false);
}
}
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 override void OnNext(IObserverDto <ProtocolMessage> messageDto)
{
Logger.Verbose("Pre Handle Message Called");
try
{
HandleResponse(messageDto.Payload.FromProtocolMessage <TProto>(), messageDto.Context,
messageDto.Payload.PeerId, messageDto.Payload.CorrelationId.ToCorrelationId());
}
catch (Exception exception)
{
Logger.Error(exception, "Failed to handle response message");
}
}
private T SubscriptionOutPipeline <T>(IObserverDto <ProtocolMessage> observer) where T : IMessage <T>
{
var message = observer.Payload.FromProtocolMessage <T>();
if (!_handlers.ContainsKey(observer.Payload.TypeUrl))
{
throw new ResponseHandlerDoesNotExistException(
$"Response Handler does not exist for message type {observer.Payload.TypeUrl}");
}
var handler = _handlers[observer.Payload.TypeUrl];
handler.HandleResponseObserver(message, observer.Context, observer.Payload.PeerId,
observer.Payload.CorrelationId.ToCorrelationId());
return(message);
}
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)
{
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;
}
if (deserialized.IsValid())
{
_deltaVoter.OnNext(deserialized);
}
}
catch (Exception exception)
{
Logger.Error(exception,
$"Failed to process candidate 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.");
}
}
public override void OnNext(IObserverDto <ProtocolMessage> messageDto)
{
SubstituteObserver.OnNext(messageDto.Payload.FromProtocolMessage <TProto>());
}
public abstract void OnNext(IObserverDto <ProtocolMessage> messageDto);
public abstract void HandleBroadcast(IObserverDto <ProtocolMessage> messageDto);
public void HandleResponse(IObserverDto <ProtocolMessage> messageDto)
{
SubstituteObserver.OnNext(messageDto.Payload.FromProtocolMessage <TProto>());
}