public virtual async Task ProcessBlockAsync(long blockNumber)
        {
            if (_lastBlock != blockNumber)
            {
                ClearCacheOfProcessedTransactions();
                _lastBlock = blockNumber;
            }

            var block = await BlockProxy.GetBlockWithTransactionsAsync(blockNumber);

            if (block == null)
            {
                throw new BlockNotFoundException(blockNumber);
            }

            if (await _blockFilters.IsMatchAsync(block))
            {
                await _blockHandler.HandleAsync(block);

                if (ProcessTransactionsInParallel)
                {
                    await ProcessTransactionsMultiThreaded(block);
                }
                else
                {
                    await ProcessTransactions(block);
                }
            }
        }
Beispiel #2
0
        public override void TraceVisitBlock(BlockProxy block)
        {
            if (!trace)
            {
                return;
            }

            Console.Write("block " + block.Block.Ordinal + ": ");
            if (block.Block.Operations.FirstOrDefault() is IOperation firstBlockOp)
            {
                Console.WriteLine(firstBlockOp.Syntax.ToString());
            }
            else if (block.Block.BranchValue is IOperation branchOp)
            {
                Console.WriteLine(branchOp.Syntax.ToString());
            }
            else
            {
                Console.WriteLine();
            }
            Console.Write("predecessors: ");
            foreach (var predecessor in cfg.GetPredecessors(block))
            {
                var predProxy = predecessor.Block;
                Console.Write(predProxy.Block.Ordinal + " ");
            }
            Console.WriteLine();
        }
        public override async Task ProcessBlockAsync(long blockNumber)
        {
            var block = await BlockProxy.GetBlockWithTransactionsAsync(blockNumber);

            //no need to save the block again
            await ProcessTransactions(block);
        }
Beispiel #4
0
        private void SelectBlockMethod(BlockProxy selectedBlock)
        {
            ChangeShownTask(SelectedTabTag);
            List <TaskEntity> exportValues = new List <TaskEntity>();

            foreach (TaskEntity task in _nullTask.ChildTasks)
            {
                foreach (ProcessProxy process in task.Processes)
                {
                    Process timeSheetProcess = AllProcessesFromTimeSheet.FirstOrDefault(i => i.id == process.ProcessId);
                    if (timeSheetProcess.Block_id == selectedBlock.BlockId)
                    {
                        exportValues.Add(task);
                        break;
                    }
                }
            }
            FillNullTask(exportValues);
            IsBlockSelectionActive = false;
        }
 public virtual async Task <long> GetMaxBlockNumberAsync()
 {
     return(await BlockProxy.GetMaxBlockNumberAsync());
 }
 public virtual Task <ulong> GetMaxBlockNumberAsync()
 {
     return(BlockProxy.GetMaxBlockNumberAsync());
 }