mirror of
https://github.com/status-im/nim-codex.git
synced 2025-02-13 03:06:43 +00:00
de88fd2c53
* implement a logging proxy The logging proxy: - prevents the need to import chronicles (as well as export except toJson), - prevents the need to override `writeValue` or use or import nim-json-seralization elsewhere in the codebase, allowing for sole use of utils/json for de/serialization, - and handles json formatting correctly in chronicles json sinks * Rename logging -> logutils to avoid ambiguity with common names * clean up * add setProperty for JsonRecord, remove nim-json-serialization conflict * Allow specifying textlines and json format separately Not specifying a LogFormat will apply the formatting to both textlines and json sinks. Specifying a LogFormat will apply the formatting to only that sink. * remove unneeded usages of std/json We only need to import utils/json instead of std/json * move serialization from rest/json to utils/json so it can be shared * fix NoColors ambiguity Was causing unit tests to fail on Windows. * Remove nre usage to fix Windows error Windows was erroring with `could not load: pcre64.dll`. Instead of fixing that error, remove the pcre usage :) * Add logutils module doc * Shorten logutils.formatIt for `NBytes` Both json and textlines formatIt were not needed, and could be combined into one formatIt * remove debug integration test config debug output and logformat of json for integration test logs * Use ## module doc to support docgen * bump nim-poseidon2 to export fromBytes Before the changes in this branch, fromBytes was likely being resolved by nim-stew, or other dependency. With the changes in this branch, that dependency was removed and fromBytes could no longer be resolved. By exporting fromBytes from nim-poseidon, the correct resolution is now happening. * fixes to get compiling after rebasing master * Add support for Result types being logged using formatIt
112 lines
3.6 KiB
Nim
112 lines
3.6 KiB
Nim
import std/sets
|
|
import std/sequtils
|
|
import pkg/chronos
|
|
import ./market
|
|
import ./clock
|
|
import ./logutils
|
|
|
|
export market
|
|
export sets
|
|
|
|
type
|
|
Validation* = ref object
|
|
slots: HashSet[SlotId]
|
|
maxSlots: int
|
|
clock: Clock
|
|
market: Market
|
|
subscriptions: seq[Subscription]
|
|
running: Future[void]
|
|
periodicity: Periodicity
|
|
proofTimeout: UInt256
|
|
|
|
logScope:
|
|
topics = "codex validator"
|
|
|
|
proc new*(
|
|
_: type Validation,
|
|
clock: Clock,
|
|
market: Market,
|
|
maxSlots: int
|
|
): Validation =
|
|
## Create a new Validation instance
|
|
Validation(clock: clock, market: market, maxSlots: maxSlots)
|
|
|
|
proc slots*(validation: Validation): seq[SlotId] =
|
|
validation.slots.toSeq
|
|
|
|
proc getCurrentPeriod(validation: Validation): UInt256 =
|
|
return validation.periodicity.periodOf(validation.clock.now().u256)
|
|
|
|
proc waitUntilNextPeriod(validation: Validation) {.async.} =
|
|
let period = validation.getCurrentPeriod()
|
|
let periodEnd = validation.periodicity.periodEnd(period)
|
|
trace "Waiting until next period", currentPeriod = period
|
|
await validation.clock.waitUntil(periodEnd.truncate(int64) + 1)
|
|
|
|
proc subscribeSlotFilled(validation: Validation) {.async.} =
|
|
proc onSlotFilled(requestId: RequestId, slotIndex: UInt256) =
|
|
let slotId = slotId(requestId, slotIndex)
|
|
if slotId notin validation.slots:
|
|
if validation.slots.len < validation.maxSlots:
|
|
trace "Adding slot", slotId
|
|
validation.slots.incl(slotId)
|
|
let subscription = await validation.market.subscribeSlotFilled(onSlotFilled)
|
|
validation.subscriptions.add(subscription)
|
|
|
|
proc removeSlotsThatHaveEnded(validation: Validation) {.async.} =
|
|
var ended: HashSet[SlotId]
|
|
for slotId in validation.slots:
|
|
let state = await validation.market.slotState(slotId)
|
|
if state != SlotState.Filled:
|
|
trace "Removing slot", slotId
|
|
ended.incl(slotId)
|
|
validation.slots.excl(ended)
|
|
|
|
proc markProofAsMissing(validation: Validation,
|
|
slotId: SlotId,
|
|
period: Period) {.async.} =
|
|
logScope:
|
|
currentPeriod = validation.getCurrentPeriod()
|
|
|
|
try:
|
|
if await validation.market.canProofBeMarkedAsMissing(slotId, period):
|
|
trace "Marking proof as missing", slotId, periodProofMissed = period
|
|
await validation.market.markProofAsMissing(slotId, period)
|
|
else:
|
|
let inDowntime {.used.} = await validation.market.inDowntime(slotId)
|
|
trace "Proof not missing", checkedPeriod = period, inDowntime
|
|
except CancelledError:
|
|
raise
|
|
except CatchableError as e:
|
|
error "Marking proof as missing failed", msg = e.msg
|
|
|
|
proc markProofsAsMissing(validation: Validation) {.async.} =
|
|
for slotId in validation.slots:
|
|
let previousPeriod = validation.getCurrentPeriod() - 1
|
|
await validation.markProofAsMissing(slotId, previousPeriod)
|
|
|
|
proc run(validation: Validation) {.async.} =
|
|
trace "Validation started"
|
|
try:
|
|
while true:
|
|
await validation.waitUntilNextPeriod()
|
|
await validation.removeSlotsThatHaveEnded()
|
|
await validation.markProofsAsMissing()
|
|
except CancelledError:
|
|
trace "Validation stopped"
|
|
discard
|
|
except CatchableError as e:
|
|
error "Validation failed", msg = e.msg
|
|
|
|
proc start*(validation: Validation) {.async.} =
|
|
validation.periodicity = await validation.market.periodicity()
|
|
validation.proofTimeout = await validation.market.proofTimeout()
|
|
await validation.subscribeSlotFilled()
|
|
validation.running = validation.run()
|
|
|
|
proc stop*(validation: Validation) {.async.} =
|
|
await validation.running.cancelAndWait()
|
|
while validation.subscriptions.len > 0:
|
|
let subscription = validation.subscriptions.pop()
|
|
await subscription.unsubscribe()
|