public void Should_Reconcile_On_New_Delta_Hash() { var hash1 = _hashProvider.ComputeUtf8MultiHash("update"); var hash2 = _hashProvider.ComputeUtf8MultiHash("update again"); var updates = new[] { hash1, hash2 }; _ledgerSynchroniser.CacheDeltasBetween(default, default, default)
public async Task GetHighestDeltaIndexAsync_Should_Return_DeltaIndex() { var deltaHeight = 100u; GeneratePeers(100); _peerClient.When(x => x.SendMessageToPeers(Arg.Any <IMessage>(), Arg.Any <IEnumerable <PeerId> >())).Do(x => { var peerIds = (IEnumerable <PeerId>)x[1]; foreach (var peerId in peerIds) { var deltaHeightResponse = new LatestDeltaHashResponse { DeltaIndex = new DeltaIndex { Cid = _hashProvider.ComputeUtf8MultiHash(deltaHeight.ToString()).ToCid().ToArray().ToByteString(), Height = deltaHeight }, IsSync = true }; _deltaHeightReplaySubject.OnNext(new ObserverDto(Substitute.For <IChannelHandlerContext>(), deltaHeightResponse.ToProtocolMessage(peerId, CorrelationId.GenerateCorrelationId()))); } }); var deltaHeightWatcher = new DeltaHeightWatcher(_peerClient, _peerRepository, _peerService, minimumPeers: 0); deltaHeightWatcher.Start(); var deltaIndex = await deltaHeightWatcher.GetHighestDeltaIndexAsync(); deltaIndex.Height.Should().Be(deltaHeight); }
public void HandleBroadcast_Should_Cast_Hashes_To_Multihash_And_Try_Update() { var newHash = _hashProvider.ComputeUtf8MultiHash("newHash").CreateCid(); var prevHash = _hashProvider.ComputeUtf8MultiHash("prevHash").CreateCid(); var receivedMessage = PrepareReceivedMessage(newHash.ToArray(), prevHash.ToArray()); var deltaDfsHashObserver = new DeltaDfsHashObserver(_deltaHashProvider, _logger); deltaDfsHashObserver.HandleBroadcast(receivedMessage); _deltaHashProvider.Received(1).TryUpdateLatestHash(prevHash, newHash); }
public void TryReadDeltaFromDfs_Should_Return_False_And_Log_When_Hash_Not_Found_On_Dfs() { var exception = new FileNotFoundException("that hash is not good"); _dfs.ReadAsync(Arg.Any <Cid>(), Arg.Any <CancellationToken>()) .Throws(exception); var cid = _hashProvider.ComputeUtf8MultiHash("bad hash").CreateCid(); _dfsReader.TryReadDeltaFromDfs(cid, out _, CancellationToken.None).Should().BeFalse(); _logger.Received(1).Error(exception, Arg.Any <string>(), Arg.Is <Cid>(s => s == cid)); }
public LedgerTests() { _testScheduler = new TestScheduler(); _fakeRepository = Substitute.For <IAccountRepository>(); _hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256")); _mapperProvider = new TestMapperProvider(); _logger = Substitute.For <ILogger>(); _mempool = Substitute.For <IMempool <PublicEntryDao> >(); _deltaHashProvider = Substitute.For <IDeltaHashProvider>(); _receipts = Substitute.For <ITransactionRepository>(); _synchroniser = Substitute.For <ISynchroniser>(); _genesisHash = _hashProvider.ComputeUtf8MultiHash("genesis").ToCid(); _synchroniser.DeltaCache.GenesisHash.Returns(_genesisHash); _executor = Substitute.For <IDeltaExecutor>(); _stateProvider = Substitute.For <IStateProvider>(); _storageProvider = Substitute.For <IStorageProvider>(); _cryptoContext = new FfiWrapper(); _signingContext = new SigningContext { NetworkType = NetworkType.Devnet, SignatureType = SignatureType.TransactionPublic }; _deltaIndexService = new DeltaIndexService(new InMemoryRepository <DeltaIndexDao, string>()); }
public void Successful_Add_File_Can_Respond_With_Finished_Code() { _nodeFileTransferFactory.RegisterTransfer(Arg.Any <IDownloadFileInformation>()) .Returns(FileTransferResponseCodeTypes.Successful); var expectedCid = _hashProvider.ComputeUtf8MultiHash("expectedHash").ToCid(); var fakeBlock = Substitute.For <IFileSystemNode>(); fakeBlock.Id.Returns(expectedCid); _fakeDfsService.UnixFsApi.AddAsync(Arg.Any <Stream>(), Arg.Any <string>(), Arg.Any <AddFileOptions>()).Returns(fakeBlock); var protocolMessage = GenerateProtocolMessage(); AddFileToDfsResponse addFileToDfsResponse = null; async void UseArgument(IDownloadFileInformation information) { information.RecipientChannel = Substitute.For <IChannel>(); information.UpdateChunkIndicator(0, true); information.Dispose(); await information.RecipientChannel.WriteAndFlushAsync(Arg.Do <MessageDto>(x => { addFileToDfsResponse = x.Content.FromProtocolMessage <AddFileToDfsResponse>(); _manualResetEvent.Set(); })); } _nodeFileTransferFactory.RegisterTransfer(Arg.Do <IDownloadFileInformation>(UseArgument)); protocolMessage.SendToHandler(_fakeContext, _addFileToDfsRequestObserver); _manualResetEvent.WaitOne(); addFileToDfsResponse.ResponseCode[0].Should().Be((byte)FileTransferResponseCodeTypes.Finished.Id); addFileToDfsResponse.DfsHash.Should().Be(expectedCid); }
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 DeltaBuilderTests() { _hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256")); _random = new Random(); _randomFactory = Substitute.For <IDeterministicRandomFactory>(); _randomFactory.GetDeterministicRandomFromSeed(Arg.Any <byte[]>()) .Returns(ci => new IsaacRandom(((byte[])ci[0]).ToHex())); _producerId = PeerIdHelper.GetPeerId("producer"); _peerSettings = _producerId.ToSubstitutedPeerSettings(); _previousDeltaHash = _hashProvider.ComputeUtf8MultiHash("previousDelta").CreateCid(); _zeroCoinbaseEntry = new CoinbaseEntry { Amount = UInt256.Zero.ToUint256ByteString(), ReceiverPublicKey = _producerId.PublicKey.ToByteString() }; _logger = Substitute.For <ILogger>(); _cache = Substitute.For <IDeltaCache>(); _dateTimeProvider = new DateTimeProvider(); }
public async Task GetDeltaRequestObserver_Should_Send_Response_When_Delta_Found_In_Cache() { var cid = _hashProvider.ComputeUtf8MultiHash("abcd").CreateCid(); var delta = CreateAndExpectDeltaFromCache(cid); var observable = CreateStreamWithDeltaRequest(cid); _observer.StartObserving(observable); _testScheduler.Start(); _deltaCache.Received(1).TryGetOrAddConfirmedDelta(Arg.Is <Cid>( s => s.Equals(cid)), out Arg.Any <Delta>()); await _fakeContext.Channel.ReceivedWithAnyArgs(1) .WriteAndFlushAsync(Arg.Is <IMessageDto <ProtocolMessage> >(pm => pm.Content.FromProtocolMessage <GetDeltaResponse>().Delta.PreviousDeltaDfsHash == delta.PreviousDeltaDfsHash)); }
public void Should_Reconcile_On_New_Delta_Hash() { var hash1 = _hashProvider.ComputeUtf8MultiHash("update").ToCid(); var hash2 = _hashProvider.ComputeUtf8MultiHash("update again").ToCid(); var updates = new[] { hash1, hash2 }; _synchroniser.CacheDeltasBetween(Arg.Is(_genesisHash), Arg.Is(hash1), default) .ReturnsForAnyArgs(new[] { hash2, hash1, _genesisHash }); _deltaHashProvider.DeltaHashUpdates.Returns(updates.ToObservable(_testScheduler)); _ledger = new Ledger(_executor, _stateProvider, _storageProvider, new StateDb(), new StateDb(), _fakeRepository, _deltaIndexService, _receipts, _deltaHashProvider, _synchroniser, _mempool, _mapperProvider, _hashProvider, _logger); _testScheduler.Start(); _ledger.LatestKnownDelta.Should().Be(_genesisHash); }
public void Init() { _hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256")); _random = new Random(1); _randomFactory = Substitute.For <IDeterministicRandomFactory>(); _randomFactory.GetDeterministicRandomFromSeed(Arg.Any <byte[]>()) .Returns(ci => new IsaacRandom(((byte[])ci[0]).ToHex())); _producerId = PeerIdHelper.GetPeerId("producer"); _peerSettings = _producerId.ToSubstitutedPeerSettings(); _previousDeltaHash = _hashProvider.ComputeUtf8MultiHash("previousDelta").ToCid(); _zeroCoinbaseEntry = new CoinbaseEntry { Amount = UInt256.Zero.ToUint256ByteString(), ReceiverPublicKey = _producerId.PublicKey.ToByteString() }; _logger = Substitute.For <ILogger>(); _cache = Substitute.For <IDeltaCache>(); Delta previousDelta = new Delta(); previousDelta.StateRoot = ByteString.CopyFrom(Keccak.EmptyTreeHash.Bytes); _cache.TryGetOrAddConfirmedDelta(Arg.Any <Cid>(), out Arg.Any <Delta>()).Returns(x => { x[1] = previousDelta; return(true); }); _dateTimeProvider = new DateTimeProvider(); IDb codeDb = new MemDb(); ISnapshotableDb stateDb = new StateDb(); ISpecProvider specProvider = new CatalystSpecProvider(); _cryptoContext = new FfiWrapper(); _stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance); IStorageProvider storageProvider = new StorageProvider(stateDb, _stateProvider, LimboLogs.Instance); KatVirtualMachine virtualMachine = new KatVirtualMachine(_stateProvider, storageProvider, new StateUpdateHashProvider(), specProvider, new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256")), new FfiWrapper(), LimboLogs.Instance); _deltaExecutor = new DeltaExecutor(specProvider, _stateProvider, storageProvider, virtualMachine, _cryptoContext, _logger); }
private MultiHash AddFileToDfs(long byteSize, out long crcValue, out Stream stream) { var fileToTransfer = FileHelper.CreateRandomTempFile(byteSize); var fakeId = _hashProvider.ComputeUtf8MultiHash(CorrelationId.GenerateCorrelationId().ToString()); crcValue = FileHelper.GetCrcValue(fileToTransfer); stream = new MemoryStream(File.ReadAllBytes(fileToTransfer)); _dfsService.UnixFsApi.ReadFileAsync(fakeId.ToString()).Returns(stream); return(fakeId); }
/// <inheritdoc /> public async Task <Cid> AddTextAsync(string utf8Content, CancellationToken cancellationToken = default) { var cid = _hashProvider.ComputeUtf8MultiHash(utf8Content).CreateCid(); var filePath = Path.Combine(_baseFolder.FullName, cid); await _fileSystem.File.WriteAllTextAsync( filePath, utf8Content, Encoding.UTF8, cancellationToken); return(cid); }
private IObserverDto <ProtocolMessage> GetFileFromDfsRequestMessage() { var getFileFromDfsRequestMessage = new GetFileFromDfsRequest { DfsHash = _hashProvider.ComputeUtf8MultiHash("test").ToBase32() }; var protocolMessage = getFileFromDfsRequestMessage .ToProtocolMessage(PeerIdHelper.GetPeerId("TestMan"), CorrelationId.GenerateCorrelationId()); return(new ObserverDto(Substitute.For <IChannelHandlerContext>(), protocolMessage)); }
private DeltaHistoryResponse GenerateSampleData(int height, int range, int maxHeight = -1) { var deltaHeightResponse = new DeltaHistoryResponse(); var deltaIndexList = new List <DeltaIndex>(); var heightSum = height + range; if (heightSum > maxHeight) { heightSum = maxHeight; } for (var i = height; i <= heightSum; i++) { deltaIndexList.Add(new DeltaIndex { Cid = ByteString.CopyFrom(_hashProvider.ComputeUtf8MultiHash(i.ToString()).ToCid().ToArray()), Height = (uint)i }); } deltaHeightResponse.DeltaIndex.Add(deltaIndexList); return(deltaHeightResponse); }
public LedgerTests() { _testScheduler = new TestScheduler(); _fakeRepository = Substitute.For <IAccountRepository>(); _hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256")); _logger = Substitute.For <ILogger>(); _mempool = Substitute.For <IMempool <MempoolDocument> >(); _deltaHashProvider = Substitute.For <IDeltaHashProvider>(); _ledgerSynchroniser = Substitute.For <ILedgerSynchroniser>(); _genesisHash = _hashProvider.ComputeUtf8MultiHash("genesis"); _ledgerSynchroniser.DeltaCache.GenesisHash.Returns(_genesisHash); _ledgerSynchroniser.DeltaCache.GenesisAddress.Returns(_genesisHash.ToBase32()); }
public void TryGetDelta_Should_Not_Hit_The_Dfs_Or_Store_Delta_When_Delta_Is_In_Cache() { _memoryCache.ClearReceivedCalls(); // needed because of the CreateEntry call from the DeltaCache .ctor var deltaFromCache = DeltaHelper.GetDelta(_hashProvider); var cid = CidHelper.CreateCid(_hashProvider.ComputeUtf8MultiHash("abc")); _memoryCache.TryGetValue(Arg.Is(cid.Hash), out Arg.Any <Delta>()) .Returns(ci => { ci[1] = deltaFromCache; return(true); }); var found = _deltaCache.TryGetOrAddConfirmedDelta(cid.Hash, out var delta); delta.Should().Be(deltaFromCache); found.Should().BeTrue(); _dfsReader.DidNotReceiveWithAnyArgs().TryReadDeltaFromDfs(default, out _);
public async Task AddTextAsync_Should_Save_File_In_Subfolder_With_Hash_As_Name() { var someGoodUtf8Content = "some good utf8 content!"; var cid = await _dfs.AddTextAsync(someGoodUtf8Content); var expectedCid = _hashProvider.ComputeUtf8MultiHash(someGoodUtf8Content).CreateCid(); await _fileSystem.File.Received(1).WriteAllTextAsync( Arg.Is(Path.Combine(_baseFolder, expectedCid.Encode())), Arg.Any <string>(), Arg.Is(Encoding.UTF8), Arg.Any <CancellationToken>()); cid.Should().Be(expectedCid); }
public async Task Can_Populate_Peers_Correctly() { var peerRepository = Substitute.For <IPeerRepository>(); var pubkey = _hashProvider.ComputeUtf8MultiHash("hello").ToBase32(); var peers = new[] { new PoaPeer { Ip = "92.207.178.198", Port = 42069, PublicKey = pubkey }, new PoaPeer { Ip = "127.0.0.1", Port = 42069, PublicKey = pubkey } }; await FileSystem.WriteTextFileToCddAsync(PoaDiscovery.PoaPeerFile, JsonConvert.SerializeObject(peers)); var peerDiscovery = new PoaDiscovery(peerRepository, FileSystem, Substitute.For <ILogger>()); await peerDiscovery.DiscoveryAsync().ConfigureAwait(false); peerRepository.Received(peers.Length).Add(Arg.Any <Peer>()); }
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); }