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 Ledger(IDeltaExecutor deltaExecutor,
IStateProvider stateProvider,
IStorageProvider storageProvider,
ISnapshotableDb stateDb,
ISnapshotableDb codeDb,
IAccountRepository accounts,
IDeltaHashProvider deltaHashProvider,
ILedgerSynchroniser synchroniser,
IMempool <PublicEntryDao> mempool,
IMapperProvider mapperProvider,
ILogger logger)
{
Accounts = accounts;
_deltaExecutor = deltaExecutor;
_stateProvider = stateProvider;
_storageProvider = storageProvider;
_stateDb = stateDb;
_codeDb = codeDb;
_synchroniser = synchroniser;
_mempool = mempool;
_mapperProvider = mapperProvider;
_logger = logger;
_deltaUpdatesSubscription = deltaHashProvider.DeltaHashUpdates.Subscribe(Update);
LatestKnownDelta = _synchroniser.DeltaCache.GenesisHash;
}
public Synchroniser(SyncState syncState,
IPeerSyncManager peerSyncManager,
IDeltaCache deltaCache,
IDeltaHeightWatcher deltaHeightWatcher,
IDeltaHashProvider deltaHashProvider,
IDeltaDfsReader deltaDfsReader,
IDeltaIndexService deltaIndexService,
IMapperProvider mapperProvider,
IUserOutput userOutput,
ILogger logger,
int rangeSize = 20, //cannot go over 20 until udp network fragmentation is fixed
IScheduler scheduler = null)
{
State = syncState;
_peerSyncManager = peerSyncManager;
_deltaHeightWatcher = deltaHeightWatcher;
DeltaCache = deltaCache;
_rangeSize = rangeSize;
_deltaIndexService = deltaIndexService;
_mapperProvider = mapperProvider;
_userOutput = userOutput;
_deltaHashProvider = deltaHashProvider;
_logger = logger;
_syncCompletedReplaySubject = new ReplaySubject <ulong>(1, scheduler ?? Scheduler.Default);
SyncCompleted = _syncCompletedReplaySubject.AsObservable();
}
public CycleEventsProviderTests(ITestOutputHelper output)
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_output = output;
_testScheduler = new TestScheduler();
_schedulerProvider = Substitute.For <ICycleSchedulerProvider>();
_schedulerProvider.Scheduler.Returns(_testScheduler);
_dateTimeProvider = Substitute.For <IDateTimeProvider>();
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_logger = Substitute.For <ILogger>();
_deltaHashProvider.GetLatestDeltaHash(Arg.Any <DateTime>())
.Returns(hashProvider.ComputeUtf8MultiHash("test"));
_dateTimeProvider.UtcNow.Returns(_ => _testScheduler.Now.DateTime);
_cycleProvider = new CycleEventsProvider(CycleConfiguration.Default, _dateTimeProvider, _schedulerProvider,
_deltaHashProvider, _logger);
_spy = Substitute.For <IObserver <IPhase> >();
_stopWatch = _testScheduler.StartStopwatch();
_subscription = _cycleProvider.PhaseChanges.Take(50)
.Subscribe(p =>
{
_output.WriteLine($"{_stopWatch.Elapsed.TotalSeconds} -- {p}");
_spy.OnNext(p);
}, () =>
{
_output.WriteLine($"completed after {_stopWatch.Elapsed.TotalSeconds:g}");
_spy.OnCompleted();
});
}
public DeltaDfsHashObserverTests()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_fakeChannelContext = Substitute.For <IChannelHandlerContext>();
_logger = Substitute.For <ILogger>();
}
public LedgerController(IDeltaHashProvider deltaHashProvider, IDfsService dfsService, IMapperProvider mapperProvider, ILogger logger)
{
_deltaHashProvider = deltaHashProvider;
_dfsService = dfsService;
_mapperProvider = mapperProvider;
_logger = logger;
}
public LedgerController(IDeltaHashProvider deltaHashProvider,
IDfs dfs,
IMapperProvider mapperProvider,
ILogger logger)
{
_deltaHashProvider = deltaHashProvider;
_dfs = dfs;
_mapperProvider = mapperProvider;
_logger = logger;
}
public void Init()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_fakeChannelContext = Substitute.For <IChannelHandlerContext>();
_syncState = new SyncState {
IsSynchronized = true, IsRunning = true
};
_logger = Substitute.For <ILogger>();
_peerRepository = Substitute.For <IPeerRepository>();
}
public DeltaDfsHashObserver(IDeltaHashProvider deltaHashProvider,
SyncState syncState,
IPeerRepository peerRepository,
ILogger logger)
: base(logger)
{
Guard.Argument(peerRepository, nameof(peerRepository)).NotNull();
_syncState = syncState;
_deltaHashProvider = deltaHashProvider;
_peerRepository = peerRepository;
}
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 Ledger(IAccountRepository accounts,
IDeltaHashProvider deltaHashProvider,
ILedgerSynchroniser synchroniser,
IMempool <MempoolDocument> mempool,
ILogger logger)
{
Accounts = accounts;
_synchroniser = synchroniser;
_mempool = mempool;
_logger = logger;
_deltaUpdatesSubscription = deltaHashProvider.DeltaHashUpdates.Subscribe(Update);
LatestKnownDelta = _synchroniser.DeltaCache.GenesisHash;
_cryptoContext = new FfiWrapper();
}
public Ledger(IDeltaExecutor deltaExecutor,
IStateProvider stateProvider,
IStorageProvider storageProvider,
ISnapshotableDb stateDb,
IDb codeDb,
IAccountRepository accounts,
IDeltaIndexService deltaIndexService,
ITransactionRepository receipts,
IDeltaHashProvider deltaHashProvider,
ISynchroniser synchroniser,
IMempool <PublicEntryDao> mempool,
IMapperProvider mapperProvider,
IHashProvider hashProvider,
ILogger logger)
{
Accounts = accounts;
_deltaExecutor = deltaExecutor;
_stateProvider = stateProvider;
_storageProvider = storageProvider;
_stateDb = stateDb;
_codeDb = codeDb;
_mempool = mempool;
_mapperProvider = mapperProvider;
_hashProvider = hashProvider;
_logger = logger;
_receipts = receipts;
_synchroniser = synchroniser;
_deltaUpdatesSubscription = deltaHashProvider.DeltaHashUpdates.Subscribe(Update);
_deltaIndexService = deltaIndexService;
var latestDeltaIndex = _deltaIndexService.LatestDeltaIndex();
if (latestDeltaIndex != null)
{
_latestKnownDelta = latestDeltaIndex.Cid;
_latestKnownDeltaNumber = (long)latestDeltaIndex.Height;
return;
}
_latestKnownDelta = _synchroniser.DeltaCache.GenesisHash;
WriteLatestKnownDelta(_latestKnownDelta);
}
public Consensus(IDeltaBuilder deltaBuilder,
IDeltaVoter deltaVoter,
IDeltaElector deltaElector,
IDeltaCache deltaCache,
IDeltaHub deltaHub,
ICycleEventsProvider cycleEventsProvider,
IDeltaHashProvider deltaHashProvider,
ILogger logger)
{
_deltaVoter = deltaVoter;
_deltaElector = deltaElector;
_cycleEventsProvider = cycleEventsProvider;
_deltaHashProvider = deltaHashProvider;
_deltaBuilder = deltaBuilder;
_deltaHub = deltaHub;
_deltaCache = deltaCache;
_logger = logger;
logger.Information("Consensus repository initialised.");
}
public CycleEventsProvider(ICycleConfiguration configuration,
IDateTimeProvider timeProvider,
ICycleSchedulerProvider schedulerProvider,
IDeltaHashProvider deltaHashProvider,
SyncState syncState,
ILogger logger)
{
_cancellationTokenSource = new CancellationTokenSource();
Configuration = configuration;
Scheduler = schedulerProvider.Scheduler;
var constructionStatusChanges = StatefulPhase.GetStatusChangeObservable(
PhaseName.Construction, Configuration.Construction, Configuration.CycleDuration, Scheduler);
var campaigningStatusChanges = StatefulPhase.GetStatusChangeObservable(
PhaseName.Campaigning, Configuration.Campaigning, Configuration.CycleDuration, Scheduler);
var votingStatusChanges = StatefulPhase.GetStatusChangeObservable(
PhaseName.Voting, Configuration.Voting, Configuration.CycleDuration, Scheduler);
var synchronisationStatusChanges = StatefulPhase.GetStatusChangeObservable(
PhaseName.Synchronisation, Configuration.Synchronisation, Configuration.CycleDuration, Scheduler);
_dateTimeProvider = timeProvider;
var synchronisationOffset = GetTimeSpanUntilNextCycleStart();
PhaseChanges = constructionStatusChanges
.Merge(campaigningStatusChanges, Scheduler)
.Merge(votingStatusChanges, Scheduler)
.Merge(synchronisationStatusChanges, Scheduler)
.Delay(synchronisationOffset, Scheduler)
.Where(x => syncState.IsSynchronized)
.Select(s => new Phase(deltaHashProvider.GetLatestDeltaHash(_dateTimeProvider.UtcNow), s.Name, s.Status, _dateTimeProvider.UtcNow))
.Do(p => logger.Debug("Current delta production phase {phase}", p),
exception => logger.Error(exception, "{PhaseChanges} stream failed and will stop producing cycle events.", nameof(PhaseChanges)),
() => logger.Debug("Stream {PhaseChanges} completed.", nameof(PhaseChanges)))
.TakeWhile(_ => !_cancellationTokenSource.IsCancellationRequested);
}
public void Init()
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_output = TestContext.CurrentContext;
_testScheduler = new TestScheduler();
_schedulerProvider = Substitute.For <ICycleSchedulerProvider>();
_schedulerProvider.Scheduler.Returns(_testScheduler);
_dateTimeProvider = Substitute.For <IDateTimeProvider>();
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_logger = Substitute.For <ILogger>();
_deltaHashProvider.GetLatestDeltaHash(Arg.Any <DateTime>())
.Returns(hashProvider.ComputeUtf8MultiHash("test"));
_dateTimeProvider.UtcNow.Returns(_ => _testScheduler.Now.DateTime);
_cycleProvider = new CycleEventsProvider(CycleConfiguration.Default, _dateTimeProvider, _schedulerProvider,
_deltaHashProvider, new Abstractions.Sync.SyncState()
{
IsSynchronized = true
}, _logger);
_spy = Substitute.For <IObserver <IPhase> >();
_stopWatch = _testScheduler.StartStopwatch();
_subscription = _cycleProvider.PhaseChanges.Take(50)
.Subscribe(p =>
{
TestContext.WriteLine($"{_stopWatch.Elapsed.TotalSeconds} -- {p}");
_spy.OnNext(p);
}, () =>
{
TestContext.WriteLine($"completed after {_stopWatch.Elapsed.TotalSeconds:g}");
_spy.OnCompleted();
});
}
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);
}
public DeltaDfsHashObserver(IDeltaHashProvider deltaHashProvider, IHashProvider hashProvider, ILogger logger)
: base(logger)
{
_deltaHashProvider = deltaHashProvider;
_hashProvider = hashProvider;
}
