Example #1
0
        public void Can_clear()
        {
            LruKeyCache <Address> cache = new LruKeyCache <Address>(Capacity, "test");

            cache.Set(_addresses[0]);
            cache.Clear();
            cache.Get(_addresses[0]).Should().BeFalse();
            cache.Set(_addresses[0]);
            cache.Get(_addresses[0]).Should().BeTrue();
        }
Example #2
0
        private void SaveNode(StateSyncItem syncItem, byte[] data)
        {
            if (_logger.IsTrace)
            {
                _logger.Trace($"SAVE {new string('+', syncItem.Level * 2)}{syncItem.NodeDataType.ToString().ToUpperInvariant()} {syncItem.Hash}");
            }
            Interlocked.Increment(ref _data.SavedNodesCount);
            switch (syncItem.NodeDataType)
            {
            case NodeDataType.State:
            {
                Interlocked.Increment(ref _data.SavedStateCount);
                lock (_stateDbLock)
                {
                    Interlocked.Add(ref _data.DataSize, data.Length);
                    Interlocked.Increment(ref Metrics.SyncedStateTrieNodes);
                    _stateDb.Set(syncItem.Hash, data);
                }

                break;
            }

            case NodeDataType.Storage:
            {
                lock (_codesSameAsNodes)
                {
                    if (_codesSameAsNodes.Contains(syncItem.Hash))
                    {
                        lock (_codeDbLock)
                        {
                            Interlocked.Add(ref _data.DataSize, data.Length);
                            Interlocked.Increment(ref Metrics.SyncedCodes);
                            _codeDb.Set(syncItem.Hash, data);
                        }

                        _codesSameAsNodes.Remove(syncItem.Hash);
                    }
                }

                Interlocked.Increment(ref _data.SavedStorageCount);
                lock (_stateDbLock)
                {
                    Interlocked.Add(ref _data.DataSize, data.Length);
                    Interlocked.Increment(ref Metrics.SyncedStorageTrieNodes);
                    _stateDb.Set(syncItem.Hash, data);
                }

                break;
            }

            case NodeDataType.Code:
            {
                Interlocked.Increment(ref _data.SavedCode);
                lock (_codeDbLock)
                {
                    Interlocked.Add(ref _data.DataSize, data.Length);
                    Interlocked.Increment(ref Metrics.SyncedCodes);
                    _codeDb.Set(syncItem.Hash, data);
                }

                break;
            }
            }

            if (syncItem.IsRoot)
            {
                if (_logger.IsInfo)
                {
                    _logger.Info($"Saving root {syncItem.Hash} of {_syncProgress.CurrentSyncBlock}");
                }

                VerifyPostSyncCleanUp();
                _alreadySaved.Clear();
            }

            _syncProgress.ReportSynced(syncItem.Level, syncItem.ParentBranchChildIndex, syncItem.BranchChildIndex, syncItem.NodeDataType, NodeProgressState.Saved);
            PossiblySaveDependentNodes(syncItem.Hash);
        }