Пример #1
0
        private static StateSyncItem PushItem(StateSyncFeed.IPendingSyncItems items, NodeDataType nodeDataType, int level, uint rightness, int progress = 0)
        {
            StateSyncItem stateSyncItem1 = new StateSyncItem(Keccak.Zero, nodeDataType, level, rightness);

            items.PushToSelectedStream(stateSyncItem1, progress);
            return(stateSyncItem1);
        }
Пример #2
0
 public DependentItem(StateSyncItem syncItem, byte[] value, int counter, bool isAccount = false)
 {
     SyncItem  = syncItem;
     Value     = value;
     Counter   = counter;
     IsAccount = isAccount;
 }
Пример #3
0
        public void Can_peek_root()
        {
            StateSyncFeed.IPendingSyncItems items = Init();
            StateSyncItem stateSyncItem           = new StateSyncItem(Keccak.Zero, NodeDataType.State, 0, 0);

            items.PushToSelectedStream(stateSyncItem, 0);
            items.PeekState().Should().Be(stateSyncItem);
        }
Пример #4
0
        public void Can_recalculate_and_clear_with_root_only()
        {
            StateSyncFeed.IPendingSyncItems items = Init();
            StateSyncItem stateSyncItem           = new StateSyncItem(Keccak.Zero, NodeDataType.State, 0, 0);

            items.PushToSelectedStream(stateSyncItem, 0);
            items.RecalculatePriorities();
            items.Clear();
            items.Count.Should().Be(0);
        }
Пример #5
0
        public override Task <StateSyncBatch?> PrepareRequest()
        {
            StateSyncBatch?request;

            lock (_requestedNodes)
            {
                if (_requestedNodes.Count == 0)
                {
                    return(Task.FromResult((StateSyncBatch?)null));
                }

                StateSyncItem[] requestedNodes;
                if (_requestedNodes.Count < StateSyncFeed.MaxRequestSize)
                {
                    // do not make it state sync item :)
                    requestedNodes = _requestedNodes.Select(n => new StateSyncItem(n, NodeDataType.State)).ToArray();
                    _requestedNodes.Clear();
                }
                else
                {
                    Keccak[] source = _requestedNodes.ToArray();
                    requestedNodes = new StateSyncItem[StateSyncFeed.MaxRequestSize];
                    _requestedNodes.Clear();
                    for (int i = 0; i < source.Length; i++)
                    {
                        if (i < StateSyncFeed.MaxRequestSize)
                        {
                            // not state sync item
                            requestedNodes[i] = new StateSyncItem(source[i], NodeDataType.State);
                        }
                        else
                        {
                            _requestedNodes.Add(source[i]);
                        }
                    }
                }

                request            = new StateSyncBatch(requestedNodes);
                request.ConsumerId = FeedId;
            }

            Interlocked.Increment(ref Metrics.BeamedRequests);
            return(Task.FromResult <StateSyncBatch?>(request));
        }