Jordan Hrycaj 3936d4d0ad
Aristo db fixes n updates needed for filter fifo (#1728)
* Set scheduler state as part of the backend descriptor

details:
  Moved type definitions `QidLayoutRef` and `QidSchedRef` to
 `desc_structural.nim` so that it shares the same folder as
  `desc_backend.nim`

* Automatic filter queue table initialisation in backend

details:
  Scheduler can be tweaked or completely disabled

* Updated backend unit tests

details:
+ some code clean up/beautification, reads better now
+ disabled persistent filters so that there is no automated filter
   management which will be implemented next

* Prettify/update unit tests source code

details:
  Mostly replacing the `check()` paradigm by `xCheck()`

* Somewhat simplified backend type management

why:
  Backend objects are labelled with a `BackendType` symbol where the
  `BackendVoid` label is implicitly assumed for a `nil` backend object
  reference.

  To make it easier, a `kind()` function is used now applicable to
  `nil` references as well.

* Fix DB storage layout for filter objects

why:
  Need to store the filter ID with the object

* Implement reverse [] index on fifo

why:
  An integer index argument on `[]` retrieves the QueueID (label) of the
  fifo item while a QueueID argument on `[]` retrieves the index (so
  it is inverse to the former variant).

* Provide iterator over filters as fifo

why:
  This iterator goes along the cascased fifo structure (i.e. in
  historical order)
2023-09-05 14:57:20 +01:00

108 lines
3.3 KiB
Nim

# nimbus-eth1
# Copyright (c) 2021 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
# http://www.apache.org/licenses/LICENSE-2.0)
# * MIT license ([LICENSE-MIT](LICENSE-MIT) or
# http://opensource.org/licenses/MIT)
# at your option. This file may not be copied, modified, or distributed
# except according to those terms.
## Non persistent constructors for Aristo DB
## =========================================
##
{.push raises: [].}
import
std/sets,
results,
../aristo_desc,
../aristo_desc/desc_backend,
"."/[init_common, memory_db]
type
VoidBackendRef* = ref object of TypedBackendRef
## Dummy descriptor type, will typically used as `nil` reference
export
BackendType,
MemBackendRef
let
DefaultQidLayoutRef* = DEFAULT_QID_QUEUES.to(QidLayoutRef)
# ------------------------------------------------------------------------------
# Public database constuctors, destructor
# ------------------------------------------------------------------------------
proc newAristoDbRef*(
backend: static[BackendType];
qidLayout = DefaultQidLayoutRef;
): AristoDbRef =
## Simplified prototype for `BackendNone` and `BackendMemory` type backend.
##
## If the `qidLayout` argument is set `QidLayoutRef(nil)`, the a backend
## database will not provide filter history management. Providing a different
## scheduler layout shoud be used with care as table access with different
## layouts might render the filter history data unmanageable.
##
when backend == BackendVoid:
AristoDbRef(top: LayerRef())
elif backend == BackendMemory:
AristoDbRef(top: LayerRef(), backend: memoryBackend(qidLayout))
elif backend == BackendRocksDB:
{.error: "Aristo DB backend \"BackendRocksDB\" needs basePath argument".}
else:
{.error: "Unknown/unsupported Aristo DB backend".}
# -----------------
proc finish*(db: AristoDbRef; flush = false) =
## Backend destructor. The argument `flush` indicates that a full database
## deletion is requested. If set ot left `false` the outcome might differ
## depending on the type of backend (e.g. the `BackendMemory` backend will
## always flush on close.)
##
## In case of distributed descriptors accessing the same backend, all
## distributed descriptors will be destroyed.
##
## This distructor may be used on already *destructed* descriptors.
##
if not db.isNil:
if not db.backend.isNil:
db.backend.closeFn flush
if db.dudes.isNil:
db[] = AristoDbObj()
else:
let lebo = if db.dudes.rwOk: db else: db.dudes.rwDb
for w in lebo.dudes.roDudes:
w[] = AristoDbObj()
lebo[] = AristoDbObj()
# -----------------
proc to*[W: TypedBackendRef|MemBackendRef|VoidBackendRef](
db: AristoDbRef;
T: type W;
): T =
## Handy helper for lew-level access to some backend functionality
db.backend.T
proc kind*(
be: BackendRef;
): BackendType =
## Retrieves the backend type symbol for a `TypedBackendRef` argument where
## `BackendVoid` is returned for the`nil` backend.
if be.isNil:
BackendVoid
else:
be.TypedBackendRef.beKind
# ------------------------------------------------------------------------------
# End
# ------------------------------------------------------------------------------