* Update unprocessed blocks bookkeeping avoiding race condition
details:
Instead of keeping track in `borrowed` of the sum of a set of blocks
fetched from the `unprocessed` list, the particular ranges details are
stored. When committing a particular range, the range itself (rather
then its length) is removed from the `borrowed` data.
why:
The function `blocksUnprocAmend()`) may produce a race condition, so it
was re-implemented as `blocksUnprocAppend()` considering range overlaps
with borrowed.
* Clean up/re-org `blocks_unproc` module
why:
The `borrowed` data structure can be fully maintained with the
`blocksUnprocXxx()` functions.
* Update/simplify unprocessed headers bookkeeping (similar as for blocks)
* Removing stashed headers right after successfully assembled blocks
why:
Was previously deleted after importing blocks although it is not needed
anymore after blocks have been assembled using bodies fetched over
the ethXX network.
* Always curb the blocks to the initialised length
why:
Some error exit directives missed some clean up leaving the blocks
list with empty/stale block bodies.
* Enter reorg-mode right away after block import error
why:
There is not much one can do. Typically, this type of error is due
to a switch to a different canonical chain. When this happens, the
block batch is expected to be relatively short as the cause for a
chain switch is an RPC instruction. This in turn is effective if some
of the blocks on the `FC` database are maintained by the `CL`.
* aristo: fork support via layers/txframes
This change reorganises how the database is accessed: instead holding a
"current frame" in the database object, a dag of frames is created based
on the "base frame" held in `AristoDbRef` and all database access
happens through this frame, which can be thought of as a consistent
point-in-time snapshot of the database based on a particular fork of the
chain.
In the code, "frame", "transaction" and "layer" is used to denote more
or less the same thing: a dag of stacked changes backed by the on-disk
database.
Although this is not a requirement, in practice each frame holds the
change set of a single block - as such, the frame and its ancestors
leading up to the on-disk state represents the state of the database
after that block has been applied.
"committing" means merging the changes to its parent frame so that the
difference between them is lost and only the cumulative changes remain -
this facility enables frames to be combined arbitrarily wherever they
are in the dag.
In particular, it becomes possible to consolidate a set of changes near
the base of the dag and commit those to disk without having to re-do the
in-memory frames built on top of them - this is useful for "flattening"
a set of changes during a base update and sending those to storage
without having to perform a block replay on top.
Looking at abstractions, a side effect of this change is that the KVT
and Aristo are brought closer together by considering them to be part of
the "same" atomic transaction set - the way the code gets organised,
applying a block and saving it to the kvt happens in the same "logical"
frame - therefore, discarding the frame discards both the aristo and kvt
changes at the same time - likewise, they are persisted to disk together
- this makes reasoning about the database somewhat easier but has the
downside of increased memory usage, something that perhaps will need
addressing in the future.
Because the code reasons more strictly about frames and the state of the
persisted database, it also makes it more visible where ForkedChain
should be used and where it is still missing - in particular, frames
represent a single branch of history while forkedchain manages multiple
parallel forks - user-facing services such as the RPC should use the
latter, ie until it has been finalized, a getBlock request should
consider all forks and not just the blocks in the canonical head branch.
Another advantage of this approach is that `AristoDbRef` conceptually
becomes more simple - removing its tracking of the "current" transaction
stack simplifies reasoning about what can go wrong since this state now
has to be passed around in the form of `AristoTxRef` - as such, many of
the tests and facilities in the code that were dealing with "stack
inconsistency" are now structurally prevented from happening. The test
suite will need significant refactoring after this change.
Once this change has been merged, there are several follow-ups to do:
* there's no mechanism for keeping frames up to date as they get
committed or rolled back - TODO
* naming is confused - many names for the same thing for legacy reason
* forkedchain support is still missing in lots of code
* clean up redundant logic based on previous designs - in particular the
debug and introspection code no longer makes sense
* the way change sets are stored will probably need revisiting - because
it's a stack of changes where each frame must be interrogated to find an
on-disk value, with a base distance of 128 we'll at minimum have to
perform 128 frame lookups for *every* database interaction - regardless,
the "dag-like" nature will stay
* dispose and commit are poorly defined and perhaps redundant - in
theory, one could simply let the GC collect abandoned frames etc, though
it's likely an explicit mechanism will remain useful, so they stay for
now
More about the changes:
* `AristoDbRef` gains a `txRef` field (todo: rename) that "more or less"
corresponds to the old `balancer` field
* `AristoDbRef.stack` is gone - instead, there's a chain of
`AristoTxRef` objects that hold their respective "layer" which has the
actual changes
* No more reasoning about "top" and "stack" - instead, each
`AristoTxRef` can be a "head" that "more or less" corresponds to the old
single-history `top` notion and its stack
* `level` still represents "distance to base" - it's computed from the
parent chain instead of being stored
* one has to be careful not to use frames where forkedchain was intended
- layers are only for a single branch of history!
* fix layer vtop after rollback
* engine fix
* Fix test_txpool
* Fix test_rpc
* Fix copyright year
* fix simulator
* Fix copyright year
* Fix copyright year
* Fix tracer
* Fix infinite recursion bug
* Remove aristo and kvt empty files
* Fic copyright year
* Fix fc chain_kvt
* ForkedChain refactoring
* Fix merge master conflict
* Fix copyright year
* Reparent txFrame
* Fix test
* Fix txFrame reparent again
* Cleanup and fix test
* UpdateBase bugfix and fix test
* Fixe newPayload bug discovered by hive
* Fix engine api fcu
* Clean up call template, chain_kvt, andn txguid
* Fix copyright year
* work around base block loading issue
* Add test
* Fix updateHead bug
* Fix updateBase bug
* Change func commitBase to proc commitBase
* Touch up and fix debug mode crash
---------
Co-authored-by: jangko <jangko128@gmail.com>
* Bump RPC server buffer size
When large blocks arrive via RPC, we need to be able to read them from
the socket in reasonable time - at 4kb, we might need thousands of reads
before the JSON can be parsed - 256kb ensures that most blocks can be
read in a few loop iterations - the size doesn't greatly matter since we
only have one of these (unlike p2p connections)
* copyright
* Avoid re-compacting historical data
Per rocksdb docs, it will by default re-compact any data not touched for
30 days - this is obviously wasteful since our historical data rarely
changes and _hopefully_ can stay untouched once written (with a bit of
key sorting luck).
* copyright
* Improved logging using nimbus-eth2 options
- log file support removal
- auto detection of tty, colour support and related.
* Added EthTime serializer (implemented on eth_types_json_serialization)
* added json chronicles logging support
for some eth, web3 and confutils types
---------
Co-authored-by: Pedro Miranda <pedro.miranda@nimbus.team>
* Correct docu
why:
`T` is mentioned on the metrics table but not explained
* Update state sync ticker
why:
Print last named state for debugging unexpected states.
* Rename `nec_consensus_head`=> `nec_sync_consensus_head`
why:
This variable is syncer local, derived from what would be vaguely be
the consensus head. In fact, at some point it is the consensus head
but often will keep that value while the consensus head advances.
* Handle legit system state when block processing is cancelled
why:
This state context was previously missing. It happens with problematic
blocks (i.e. corrupt or missing.) Rather than trying to remedy the batch
queue, all will be cancelled and the batch queue rebuilt from scratch.
* Update block queue with unexpectedly missing blocks
why:
Concurrently serving `RPC` requests might cause a reset of the `FC`
module data area. This in turn might produce a gap between expected `FC`
module top and the beginning of the already downloaded blocks list.
Currently this led to a deadlock situation because the missing blocks
were never downloaded by the syncer, neither installed into `FC` module
via `RFC`.
* Fix copyright year
This was added to cleanup database from a content type that was
removed.
After ping extensions upgrade all active nodes must have been
updated to remain compatible and thus must have ran this pruning
code.
* Sync scheduler provides an independent `ticker` loop process
why:
Can be used to update `metrics` and for debug logging. While an event
driven solution would stall if there are no events at the moment (e.g.
when the syncer hibernates, the `ticker` will run regardless.
* Use `runTicker()` loop interface alike for updating ticker
why:
Not event driven anymore so it will not stall when the syncer
hibernates.
* Re-implement logging ticker by running it within the `runTicker()` driver
why:
Simplifies implementation
* Re-name metrics variable to better fit into the current naming schemes
* Fix copyright header
Discard the received data on uTP content stream read timeout.
Before the data was still added to the queue and being processed
and should normally fail in validation. However as we know not all
data got read it should not even move to the validation step.
Added however a FIN send after the timeout instead of the delayed
socket clean-up which does not make much sense in that scenario
either. Basically either be nice and still send a FIN or just
destroy the socket immediatly.
* Force metrics update when peers vanish
why:
After that there might be reduced activity so that the next metrics
update is delayed.
* Update comments (code cosmetics)
* Tidy up nano-sleep wait directives to an `update.nim`-function
* Fix copyright year
* Move EIP-7702 Authorization validation to authority func
If the authorization is invalid the transaction itself is still valid,
the invalid authorization will be skipped.
* Fix copyright year
