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>()); }