public CatalystNodePoa(IKeySigner keySigner,
IPeerService peer,
IConsensus consensus,
IDfs dfs,
ILedger ledger,
ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
IMempool <PublicEntryDao> memPool,
IContract contract = null)
{
_peer = peer;
_peerClient = peerClient;
_peerSettings = peerSettings;
Consensus = consensus;
_dfs = dfs;
_ledger = ledger;
_keySigner = keySigner;
_logger = logger;
_memPool = memPool;
_contract = contract;
var privateKey = keySigner.KeyStore.KeyStoreDecrypt(KeyRegistryTypes.DefaultKey);
_publicKey = keySigner.CryptoContext.GetPublicKeyFromPrivateKey(privateKey);
}
public CatalystNodePoa(IKeySigner keySigner,
IPeerService peer,
IConsensus consensus,
IDfsService dfsService,
ILedger ledger,
ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
IMempool <PublicEntryDao> memPool,
ISynchroniser synchronizer,
IPeerRepository peerRepository,
IContract contract = null)
{
Guard.Argument(peerRepository, nameof(peerRepository)).NotNull();
_peer = peer;
_peerClient = peerClient;
_peerSettings = peerSettings;
Consensus = consensus;
_dfsService = dfsService;
_ledger = ledger;
_keySigner = keySigner;
_logger = logger;
_memPool = memPool;
_contract = contract;
_synchronizer = synchronizer;
_peerRepository = peerRepository;
var privateKey = keySigner.KeyStore.KeyStoreDecrypt(KeyRegistryTypes.DefaultKey);
_publicKey = keySigner.CryptoContext.GetPublicKeyFromPrivateKey(privateKey);
}
/// <summary>
/// Protocol for querying a peers current delta height.
/// </summary>
/// <param name="logger"></param>
/// <param name="peerClient"></param>
/// <param name="peerSettings"></param>
/// <param name="cancellationTokenProvider"></param>
/// <param name="scheduler"></param>
public PeerQueryTipRequestRequest(ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
ICancellationTokenProvider cancellationTokenProvider,
IScheduler scheduler = null) : base(logger, peerSettings.PeerId, cancellationTokenProvider, peerClient)
{
QueryTipResponseMessageStreamer = new ReplaySubject <IPeerQueryTipResponse>(1, scheduler ?? Scheduler.Default);
}
public PeerDeltaHistoryRequest(ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
ICancellationTokenProvider cancellationTokenProvider,
IScheduler observableScheduler = null) : base(logger, peerSettings.PeerId, cancellationTokenProvider, peerClient)
{
DeltaHistoryResponseMessageStreamer = new ReplaySubject <IPeerDeltaHistoryResponse>(1, observableScheduler ?? Scheduler.Default);
}
//todo add unit tests
public PeerSyncManagerUnitTests()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_peerService = Substitute.For <IPeerService>();
_peerClient = Substitute.For <IPeerClient>();
_peerRepository = new PeerRepository(new InMemoryRepository <Peer, string>());
_deltaHeightReplaySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1);
_peerService.MessageStream.Returns(_deltaHeightReplaySubject.AsObservable());
}
public void Init()
{
_peerRepository = Substitute.For <IPeerRepository>();
_peerClient = Substitute.For <IPeerClient>();
_testPeer = new Peer
{
PeerId = PeerIdHelper.GetPeerId("TestPeer")
};
}
protected ProtocolRequestBase(ILogger logger,
PeerId senderIdentifier,
ICancellationTokenProvider cancellationTokenProvider,
IPeerClient peerClient) : base(senderIdentifier)
{
Logger = logger;
CancellationTokenProvider = cancellationTokenProvider;
PeerClient = peerClient;
}
public PeerHeartbeatCheckerTests()
{
_peerRepository = Substitute.For <IPeerRepository>();
_peerClient = Substitute.For <IPeerClient>();
_testPeer = new Peer
{
PeerId = PeerIdHelper.GetPeerId("TestPeer")
};
}
public static void SendMessageToPeers(this IPeerClient peerClient, IPeerSettings peerSettings, IMessage message, IEnumerable <PeerId> peers)
{
var protocolMessage = message.ToProtocolMessage(peerSettings.PeerId);
foreach (var peer in peers)
{
peerClient.SendMessage(new MessageDto(
protocolMessage,
peer));
}
}
public HastingsDiscovery(ILogger logger,
IPeerRepository peerRepository,
IDns dns,
IPeerSettings peerSettings,
IPeerClient peerClient,
IPeerMessageCorrelationManager peerMessageCorrelationManager,
ICancellationTokenProvider cancellationTokenProvider,
IEnumerable <IPeerClientObservable> peerClientObservables,
bool autoStart = true,
int peerDiscoveryBurnIn = 10,
IHastingsOriginator stepProposal = default,
IHastingsCareTaker hastingsCareTaker = default,
int millisecondsTimeout = 10_000,
private HastingDiscoveryTest(ILogger logger = default,
IPeerRepository peerRepository = default,
IPeerSettings peerSettings = default,
IDns dns = default,
IPeerClient peerClient = default,
IPeerMessageCorrelationManager peerMessageCorrelationManager = default,
ICancellationTokenProvider cancellationTokenProvider = default,
IEnumerable <IPeerClientObservable> peerClientObservables = default,
bool autoStart = true,
int peerDiscoveryBurnIn = 10,
IHastingsOriginator state = default,
IHastingsCareTaker hastingsCareTaker = default,
int millisecondsTimeout = 10_000,
public DeltaHeightWatcher(IPeerClient peerClient,
IPeerRepository peerRepository,
IPeerService peerService,
double threshold = 0.5d,
int minimumPeers = 2)
{
_peerClient = peerClient;
DeltaHeightRanker = new DeltaHeightRanker(peerRepository, 100, threshold);
_peerRepository = peerRepository;
_peerService = peerService;
_manualResetEventSlim = new ManualResetEventSlim(false);
_threshold = threshold;
_minimumPeers = minimumPeers;
}
public PeerChallenger(ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
int peerChallengeWaitTimeSeconds,
IScheduler scheduler = null)
{
var observableScheduler = scheduler ?? Scheduler.Default;
ChallengeResponseMessageStreamer = new ReplaySubject <IPeerChallengeResponse>(1, observableScheduler);
_senderIdentifier = peerSettings.PeerId;
_logger = logger;
_peerClient = peerClient;
_peerChallengeWaitTimeSeconds = peerChallengeWaitTimeSeconds;
}
public PeerChallengeRequest(ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
int ttl,
IScheduler scheduler = null)
: base(logger,
peerSettings.PeerId,
new CancellationTokenProvider(ttl),
peerClient)
{
var observableScheduler = scheduler ?? Scheduler.Default;
ChallengeResponseMessageStreamer = new ReplaySubject <IPeerChallengeResponse>(1, observableScheduler);
_senderIdentifier = peerSettings.PeerId;
_logger = logger;
_peerClient = peerClient;
_ttl = ttl;
}
/// <summary>Initializes a new instance of the <see cref="BroadcastManager"/> class.</summary>
/// <param name="peers">The peers.</param>
/// <param name="peerSettings">Peer settings</param>
/// <param name="memoryCache">The memory cache.</param>
/// <param name="peerClient">The peer client.</param>
/// <param name="signer">The signature writer</param>
/// <param name="logger"></param>
public BroadcastManager(IPeerRepository peers,
IPeerSettings peerSettings,
IMemoryCache memoryCache,
IPeerClient peerClient,
IKeySigner signer,
ILogger logger)
{
_logger = logger;
_peerId = peerSettings.PeerId;
_pendingRequests = memoryCache;
_peers = peers;
_signingContext = new SigningContext {
NetworkType = peerSettings.NetworkType, SignatureType = SignatureType.ProtocolPeer
};
_peerClient = peerClient;
_signer = signer;
_incomingBroadcastSignatureDictionary = new ConcurrentDictionary <ICorrelationId, ProtocolMessage>();
_entryOptions = () => new MemoryCacheEntryOptions()
.AddExpirationToken(new CancellationChangeToken(new CancellationTokenSource(TimeSpan.FromMinutes(10)).Token));
}
public PeerSyncManager(IPeerClient peerClient,
IPeerRepository peerRepository,
IPeerService peerService,
IUserOutput userOutput,
IDeltaHeightWatcher deltaHeightWatcher,
IDfsService dfsService,
double threshold = 0.5d,
int minimumPeers = 2,
IScheduler scheduler = null)
{
_peerClient = peerClient;
_peerRepository = peerRepository;
_peerService = peerService;
_userOutput = userOutput;
_deltaHeightWatcher = deltaHeightWatcher;
_dfsService = dfsService;
_scoredDeltaIndexRangeSubject =
new ReplaySubject <IEnumerable <DeltaIndex> >(1, scheduler ?? Scheduler.Default);
ScoredDeltaIndexRange = _scoredDeltaIndexRangeSubject.AsObservable();
_threshold = threshold;
_minimumPeers = minimumPeers;
}
public DiscoveryTestBuilder WithPeerClient(IPeerClient peerClient = default)
{
_peerClient = peerClient ?? Substitute.For <IPeerClient>();
return(this);
}
public void Init()
{
_cancellationToken = new CancellationToken();
_manualResetEventSlim = new ManualResetEventSlim(false);
_testScheduler = new TestScheduler();
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_peerSettings = Substitute.For <IPeerSettings>();
_peerSettings.PeerId.Returns(PeerIdHelper.GetPeerId());
_deltaDfsReader = Substitute.For <IDeltaDfsReader>();
_deltaDfsReader.TryReadDeltaFromDfs(Arg.Any <Cid>(), out Arg.Any <Delta>()).Returns(x => true);
_deltaCache = Substitute.For <IDeltaCache>();
_deltaCache.GenesisHash.Returns("bafk2bzacecji5gcdd6lxsoazgnbg46c3vttjwwkptiw27enachziizhhkir2w".ToCid());
_ledger = Substitute.For <ILedger>();
_peerService = Substitute.For <IPeerService>();
_deltaHashProvider = new DeltaHashProvider(_deltaCache, Substitute.For <IDeltaIndexService>(), Substitute.For <ILogger>());
_deltaIndexService = new DeltaIndexService(new InMemoryRepository <DeltaIndexDao, string>());
_deltaIndexService.Add(new DeltaIndexDao {
Cid = _hashProvider.ComputeUtf8MultiHash("0").ToCid(), Height = 0
});
_peerClient = Substitute.For <IPeerClient>();
ModifyPeerClient <LatestDeltaHashRequest>((request, senderPeerIdentifier) =>
{
var deltaHeightResponse = new LatestDeltaHashResponse
{
DeltaIndex = new DeltaIndex
{
Cid = _hashProvider.ComputeUtf8MultiHash(_syncTestHeight.ToString()).ToCid().ToArray()
.ToByteString(),
Height = (uint)_syncTestHeight
}
};
_deltaHeightReplaySubject.OnNext(new ObserverDto(Substitute.For <IChannelHandlerContext>(),
deltaHeightResponse.ToProtocolMessage(senderPeerIdentifier, CorrelationId.GenerateCorrelationId())));
});
ModifyPeerClient <DeltaHistoryRequest>((request, senderPeerIdentifier) =>
{
var data = GenerateSampleData((int)request.Height, (int)request.Range, (int)_syncTestHeight);
_deltaIndexService.Add(data.DeltaIndex.Select(x => DeltaIndexDao.ToDao <DeltaIndex>(x, _mapperProvider)));
_deltaHistoryReplaySubject.OnNext(new ObserverDto(Substitute.For <IChannelHandlerContext>(),
data
.ToProtocolMessage(senderPeerIdentifier, CorrelationId.GenerateCorrelationId())));
});
_peerRepository = new PeerRepository(new InMemoryRepository <Peer, string>());
Enumerable.Repeat(new Peer {
PeerId = PeerIdHelper.GetPeerId()
}, 5).ToList().ForEach(_peerRepository.Add);
_deltaHeightReplaySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1);
_deltaHistoryReplaySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1);
var mergeMessageStreams = _deltaHeightReplaySubject.AsObservable()
.Merge(_deltaHistoryReplaySubject.AsObservable());
_peerService.MessageStream.Returns(mergeMessageStreams);
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_deltaHashProvider.TryUpdateLatestHash(Arg.Any <Cid>(), Arg.Any <Cid>()).Returns(true);
_mapperProvider = new TestMapperProvider();
_userOutput = Substitute.For <IUserOutput>();
_deltaHeightWatcher = new DeltaHeightWatcher(_peerClient, _peerRepository, _peerService, minimumPeers: 0);
var dfsService = Substitute.For <IDfsService>();
_peerSyncManager = new PeerSyncManager(_peerClient, _peerRepository,
_peerService, _userOutput, _deltaHeightWatcher, Substitute.For <IDfsService>(), 0.7, 0);
}
