diff --git a/hive_integration/nodocker/engine/node.nim b/hive_integration/nodocker/engine/node.nim index fd9072e09..43bc49432 100644 --- a/hive_integration/nodocker/engine/node.nim +++ b/hive_integration/nodocker/engine/node.nim @@ -42,7 +42,7 @@ proc processBlock( ## implementations (but can be savely removed, as well.) ## variant of `processBlock()` where the `header` argument is explicitely set. template header: Header = blk.header - var dbTx = vmState.com.db.ctx.newTransaction() + var dbTx = vmState.com.db.ctx.txFrameBegin() defer: dbTx.dispose() let com = vmState.com @@ -89,7 +89,7 @@ proc getVmState(c: ChainRef, header: Header): # intended to accepts invalid block proc setBlock*(c: ChainRef; blk: Block): Result[void, string] = template header: Header = blk.header - let dbTx = c.db.ctx.newTransaction() + let dbTx = c.db.ctx.txFrameBegin() defer: dbTx.dispose() # Needed for figuring out whether KVT cleanup is due (see at the end) diff --git a/nimbus/core/chain/forked_chain.nim b/nimbus/core/chain/forked_chain.nim index 6565885ec..7f4aba800 100644 --- a/nimbus/core/chain/forked_chain.nim +++ b/nimbus/core/chain/forked_chain.nim @@ -140,7 +140,7 @@ proc validateBlock(c: ForkedChainRef, parent: Header, blk: Block, updateCursor: bool = true): Result[void, string] = - let dbTx = c.db.ctx.newTransaction() + let dbTx = c.db.ctx.txFrameBegin() defer: dbTx.dispose() @@ -170,7 +170,7 @@ proc replaySegment*(c: ForkedChainRef, target: Hash32) = prevHash = chain[^1].header.parentHash c.stagingTx.rollback() - c.stagingTx = c.db.ctx.newTransaction() + c.stagingTx = c.db.ctx.txFrameBegin() c.cursorHeader = c.baseHeader for i in countdown(chain.high, chain.low): c.validateBlock(c.cursorHeader, chain[i], @@ -432,7 +432,7 @@ proc updateHeadIfNecessary(c: ForkedChainRef, pvarc: PivotArc) = if c.cursorHash != pvarc.cursor.hash: if not c.stagingTx.isNil: c.stagingTx.rollback() - c.stagingTx = c.db.ctx.newTransaction() + c.stagingTx = c.db.ctx.txFrameBegin() c.replaySegment(pvarc.pvHash) c.trimCursorArc(pvarc) @@ -442,7 +442,7 @@ proc updateHeadIfNecessary(c: ForkedChainRef, pvarc: PivotArc) = if c.stagingTx.isNil: # setHead below don't go straight to db - c.stagingTx = c.db.ctx.newTransaction() + c.stagingTx = c.db.ctx.txFrameBegin() c.setHead(pvarc) @@ -511,7 +511,7 @@ proc importBlock*(c: ForkedChainRef, blk: Block): Result[void, string] = # Try to import block to canonical or side chain. # return error if the block is invalid if c.stagingTx.isNil: - c.stagingTx = c.db.ctx.newTransaction() + c.stagingTx = c.db.ctx.txFrameBegin() template header(): Header = blk.header @@ -521,7 +521,7 @@ proc importBlock*(c: ForkedChainRef, blk: Block): Result[void, string] = if header.parentHash == c.baseHash: c.stagingTx.rollback() - c.stagingTx = c.db.ctx.newTransaction() + c.stagingTx = c.db.ctx.txFrameBegin() return c.validateBlock(c.baseHeader, blk) if header.parentHash notin c.blocks: @@ -601,7 +601,7 @@ proc forkChoice*(c: ForkedChainRef, # Write segment from base+1 to newBase into database c.stagingTx.rollback() - c.stagingTx = c.db.ctx.newTransaction() + c.stagingTx = c.db.ctx.txFrameBegin() if newBase.pvNumber > c.baseHeader.number: c.replaySegment(newBase.pvHash) @@ -616,7 +616,7 @@ proc forkChoice*(c: ForkedChainRef, if c.stagingTx.isNil: # replaySegment or setHead below don't # go straight to db - c.stagingTx = c.db.ctx.newTransaction() + c.stagingTx = c.db.ctx.txFrameBegin() # Move chain state forward to current head if newBase.pvNumber < pvarc.pvNumber: diff --git a/nimbus/core/chain/persist_blocks.nim b/nimbus/core/chain/persist_blocks.nim index 0e7ab5ed9..8d1d23114 100644 --- a/nimbus/core/chain/persist_blocks.nim +++ b/nimbus/core/chain/persist_blocks.nim @@ -117,6 +117,9 @@ proc persistBlock*(p: var Persister, blk: Block): Result[void, string] = let c = p.c + if p.dbTx == nil: + p.dbTx = p.c.db.ctx.txFrameBegin() + # Full validation means validating the state root at every block and # performing the more expensive hash computations on the block itself, ie # verifying that the transaction and receipts roots are valid - when not diff --git a/nimbus/core/tx_pool/tx_packer.nim b/nimbus/core/tx_pool/tx_packer.nim index eacd57b10..0fd60d891 100644 --- a/nimbus/core/tx_pool/tx_packer.nim +++ b/nimbus/core/tx_pool/tx_packer.nim @@ -292,7 +292,7 @@ proc packerVmExec*(xp: TxPoolRef): Result[TxPacker, string] ## Rebuild `packed` bucket by selection items from the `staged` bucket ## after executing them in the VM. let db = xp.vmState.com.db - let dbTx = db.ctx.newTransaction() + let dbTx = db.ctx.txFrameBegin() defer: dbTx.dispose() var pst = xp.vmExecInit.valueOr: diff --git a/nimbus/db/aristo/aristo_api.nim b/nimbus/db/aristo/aristo_api.nim index 05f8fd403..d2490263c 100644 --- a/nimbus/db/aristo/aristo_api.nim +++ b/nimbus/db/aristo/aristo_api.nim @@ -178,7 +178,7 @@ type ## Getter, returns `true` if the argument `tx` referes to the current ## top level transaction. - AristoApiLevelFn* = + AristoApiTxFrameLevelFn* = proc(db: AristoDbRef; ): int {.noRaise.} @@ -310,7 +310,7 @@ type ## operations performed for this transactio. The previous transaction ## is returned if there was any. - AristoApiTxBeginFn* = + AristoApiTxFrameBeginFn* = proc(db: AristoDbRef; ): Result[AristoTxRef,AristoError] {.noRaise.} @@ -324,13 +324,7 @@ type ## ... continue using db ... ## tx.commit() - AristoApiTxLevelFn* = - proc(tx: AristoTxRef; - ): int - {.noRaise.} - ## Getter, positive nesting level of transaction argument `tx` - - AristoApiTxTopFn* = + AristoApiTxFrameTopFn* = proc(db: AristoDbRef; ): Result[AristoTxRef,AristoError] {.noRaise.} @@ -358,7 +352,7 @@ type hasStorageData*: AristoApiHasStorageDataFn isTop*: AristoApiIsTopFn - level*: AristoApiLevelFn + txFrameLevel*: AristoApiTxFrameLevelFn mergeAccountRecord*: AristoApiMergeAccountRecordFn mergeStorageData*: AristoApiMergeStorageDataFn @@ -373,9 +367,8 @@ type pathAsBlob*: AristoApiPathAsBlobFn persist*: AristoApiPersistFn rollback*: AristoApiRollbackFn - txBegin*: AristoApiTxBeginFn - txLevel*: AristoApiTxLevelFn - txTop*: AristoApiTxTopFn + txFrameBegin*: AristoApiTxFrameBeginFn + txFrameTop*: AristoApiTxFrameTopFn AristoApiProfNames* = enum @@ -414,9 +407,8 @@ type AristoApiProfPathAsBlobFn = "pathAsBlob" AristoApiProfPersistFn = "persist" AristoApiProfRollbackFn = "rollback" - AristoApiProfTxBeginFn = "txBegin" - AristoApiProfTxLevelFn = "txLevel" - AristoApiProfTxTopFn = "txTop" + AristoApiProfTxFrameBeginFn = "txFrameBegin" + AristoApiProfTxFrameTopFn = "txFrameTop" AristoApiProfBeGetVtxFn = "be/getVtx" AristoApiProfBeGetKeyFn = "be/getKey" @@ -471,9 +463,8 @@ when AutoValidateApiHooks: doAssert not api.pathAsBlob.isNil doAssert not api.persist.isNil doAssert not api.rollback.isNil - doAssert not api.txBegin.isNil - doAssert not api.txLevel.isNil - doAssert not api.txTop.isNil + doAssert not api.txFrameBegin.isNil + doAssert not api.txFrameTop.isNil proc validate(prf: AristoApiProfRef) = prf.AristoApiRef.validate @@ -520,7 +511,7 @@ func init*(api: var AristoApiObj) = api.hasStorageData = hasStorageData api.isTop = isTop - api.level = level + api.txFrameLevel = txFrameLevel api.mergeAccountRecord = mergeAccountRecord api.mergeStorageData = mergeStorageData @@ -533,9 +524,8 @@ func init*(api: var AristoApiObj) = api.pathAsBlob = pathAsBlob api.persist = persist api.rollback = rollback - api.txBegin = txBegin - api.txLevel = txLevel - api.txTop = txTop + api.txFrameBegin = txFrameBegin + api.txFrameTop = txFrameTop when AutoValidateApiHooks: api.validate @@ -564,7 +554,7 @@ func dup*(api: AristoApiRef): AristoApiRef = hasStorageData: api.hasStorageData, isTop: api.isTop, - level: api.level, + txFrameLevel: api.txFrameLevel, mergeAccountRecord: api.mergeAccountRecord, mergeStorageData: api.mergeStorageData, @@ -577,9 +567,8 @@ func dup*(api: AristoApiRef): AristoApiRef = pathAsBlob: api.pathAsBlob, persist: api.persist, rollback: api.rollback, - txBegin: api.txBegin, - txLevel: api.txLevel, - txTop: api.txTop) + txFrameBegin: api.txFrameBegin, + txFrameTop: api.txFrameTop) when AutoValidateApiHooks: result.validate @@ -730,20 +719,15 @@ func init*( AristoApiProfRollbackFn.profileRunner: result = api.rollback(a) - profApi.txBegin = + profApi.txFrameBegin = proc(a: AristoDbRef): auto = - AristoApiProfTxBeginFn.profileRunner: - result = api.txBegin(a) + AristoApiProfTxFrameBeginFn.profileRunner: + result = api.txFrameBegin(a) - profApi.txLevel = - proc(a: AristoTxRef): auto = - AristoApiProfTxLevelFn.profileRunner: - result = api.txLevel(a) - - profApi.txTop = + profApi.txFrameTop = proc(a: AristoDbRef): auto = - AristoApiProfTxTopFn.profileRunner: - result = api.txTop(a) + AristoApiProfTxFrameTopFn.profileRunner: + result = api.txFrameTop(a) let beDup = be.dup() if beDup.isNil: diff --git a/nimbus/db/aristo/aristo_desc/desc_error.nim b/nimbus/db/aristo/aristo_desc/desc_error.nim index d326c1d44..0e752bed2 100644 --- a/nimbus/db/aristo/aristo_desc/desc_error.nim +++ b/nimbus/db/aristo/aristo_desc/desc_error.nim @@ -232,8 +232,8 @@ type TxArgStaleTx TxArgsUseless TxBackendNotWritable - TxLevelTooDeep - TxLevelUseless + TxFrameLevelTooDeep + TxFrameLevelUseless TxNoPendingTx TxNotFound TxNotTopTx diff --git a/nimbus/db/aristo/aristo_tx.nim b/nimbus/db/aristo/aristo_tx.nim index 4f4542d14..130c8e84e 100644 --- a/nimbus/db/aristo/aristo_tx.nim +++ b/nimbus/db/aristo/aristo_tx.nim @@ -18,26 +18,7 @@ import ./aristo_tx/[tx_frame, tx_stow], ./aristo_desc -# ------------------------------------------------------------------------------ -# Public functions, getters -# ------------------------------------------------------------------------------ - -func txTop*(db: AristoDbRef): Result[AristoTxRef,AristoError] = - ## Getter, returns top level transaction if there is any. - db.txFrameTop() - -func isTop*(tx: AristoTxRef): bool = - ## Getter, returns `true` if the argument `tx` referes to the current top - ## level transaction. - tx.txFrameIsTop() - -func txLevel*(tx: AristoTxRef): int = - ## Getter, positive nesting level of transaction argument `tx` - tx.txFrameLevel() - -func level*(db: AristoDbRef): int = - ## Getter, non-negative nesting level (i.e. number of pending transactions) - db.txFrameLevel() +export tx_frame # ------------------------------------------------------------------------------ # Public functions @@ -51,51 +32,6 @@ func to*(tx: AristoTxRef; T: type[AristoDbRef]): T = # Public functions: Transaction frame # ------------------------------------------------------------------------------ -proc txBegin*(db: AristoDbRef): Result[AristoTxRef,AristoError] = - ## Starts a new transaction. - ## - ## Example: - ## :: - ## proc doSomething(db: AristoDbRef) = - ## let tx = db.begin - ## defer: tx.rollback() - ## ... continue using db ... - ## tx.commit() - ## - db.txFrameBegin() - -proc rollback*( - tx: AristoTxRef; # Top transaction on database - ): Result[void,AristoError] = - ## Given a *top level* handle, this function discards all database operations - ## performed for this transactio. The previous transaction is returned if - ## there was any. - ## - tx.txFrameRollback() - -proc commit*( - tx: AristoTxRef; # Top transaction on database - ): Result[void,AristoError] = - ## Given a *top level* handle, this function accepts all database operations - ## performed through this handle and merges it to the previous layer. The - ## previous transaction is returned if there was any. - ## - tx.txFrameCommit() - -proc collapse*( - tx: AristoTxRef; # Top transaction on database - commit: bool; # Commit if `true`, otherwise roll back - ): Result[void,AristoError] = - ## Iterated application of `commit()` or `rollback()` performing the - ## something similar to - ## :: - ## while true: - ## discard tx.commit() # ditto for rollback() - ## if db.txTop.isErr: break - ## tx = db.txTop.value - ## - tx.txFrameCollapse commit - # ------------------------------------------------------------------------------ # Public functions: save to database # ------------------------------------------------------------------------------ @@ -119,20 +55,7 @@ proc persist*( ## next recovery journal record. If non-zero, this ID must be greater than ## all previous IDs (e.g. block number when stowing after block execution.) ## - db.txStow(nxtSid, persistent=true) - -proc stow*( - db: AristoDbRef; # Database - ): Result[void,AristoError] = - ## This function is similar to `persist()` stopping short of performing the - ## final step storing on the persistent database. It fails if there is a - ## pending transaction. - ## - ## The function merges all staged data from the top layer cache onto the - ## backend stage area and leaves it there. This function can be seen as - ## a sort of a bottom level transaction `commit()`. - ## - db.txStow(nxtSid=0u64, persistent=false) + db.txPersist(nxtSid) # ------------------------------------------------------------------------------ # End diff --git a/nimbus/db/aristo/aristo_tx/tx_frame.nim b/nimbus/db/aristo/aristo_tx/tx_frame.nim index b3e526031..17610db02 100644 --- a/nimbus/db/aristo/aristo_tx/tx_frame.nim +++ b/nimbus/db/aristo/aristo_tx/tx_frame.nim @@ -17,14 +17,14 @@ import results, ".."/[aristo_desc, aristo_layers] -func txFrameIsTop*(tx: AristoTxRef): bool +func isTop*(tx: AristoTxRef): bool # ------------------------------------------------------------------------------ # Private helpers # ------------------------------------------------------------------------------ func getDbDescFromTopTx(tx: AristoTxRef): Result[AristoDbRef,AristoError] = - if not tx.txFrameIsTop(): + if not tx.isTop(): return err(TxNotTopTx) let db = tx.db if tx.level != db.stack.len: @@ -48,15 +48,11 @@ func txFrameTop*(db: AristoDbRef): Result[AristoTxRef,AristoError] = else: ok(db.txRef) -func txFrameIsTop*(tx: AristoTxRef): bool = +func isTop*(tx: AristoTxRef): bool = ## Getter, returns `true` if the argument `tx` referes to the current top ## level transaction. tx.db.txRef == tx and tx.db.top.txUid == tx.txUid -func txFrameLevel*(tx: AristoTxRef): int = - ## Getter, positive nesting level of transaction argument `tx` - tx.level - func txFrameLevel*(db: AristoDbRef): int = ## Getter, non-negative nesting level (i.e. number of pending transactions) if not db.txRef.isNil: @@ -95,7 +91,7 @@ proc txFrameBegin*(db: AristoDbRef): Result[AristoTxRef,AristoError] = ok db.txRef -proc txFrameRollback*( +proc rollback*( tx: AristoTxRef; # Top transaction on database ): Result[void,AristoError] = ## Given a *top level* handle, this function discards all database operations @@ -112,7 +108,7 @@ proc txFrameRollback*( ok() -proc txFrameCommit*( +proc commit*( tx: AristoTxRef; # Top transaction on database ): Result[void,AristoError] = ## Given a *top level* handle, this function accepts all database operations @@ -139,7 +135,7 @@ proc txFrameCommit*( ok() -proc txFrameCollapse*( +proc collapse*( tx: AristoTxRef; # Top transaction on database commit: bool; # Commit if `true`, otherwise roll back ): Result[void,AristoError] = @@ -148,8 +144,8 @@ proc txFrameCollapse*( ## :: ## while true: ## discard tx.commit() # ditto for rollback() - ## if db.txTop.isErr: break - ## tx = db.txTop.value + ## if db.txFrameTop.isErr: break + ## tx = db.txFrameTop.value ## let db = ? tx.getDbDescFromTopTx() @@ -162,7 +158,7 @@ proc txFrameCollapse*( # Public iterators # ------------------------------------------------------------------------------ -iterator txFrameWalk*(tx: AristoTxRef): (int,AristoTxRef,LayerRef,AristoError) = +iterator walk*(tx: AristoTxRef): (int,AristoTxRef,LayerRef,AristoError) = ## Walk down the transaction stack chain. let db = tx.db var tx = tx diff --git a/nimbus/db/aristo/aristo_tx/tx_stow.nim b/nimbus/db/aristo/aristo_tx/tx_stow.nim index dc1ce07d6..b141e2bda 100644 --- a/nimbus/db/aristo/aristo_tx/tx_stow.nim +++ b/nimbus/db/aristo/aristo_tx/tx_stow.nim @@ -8,7 +8,7 @@ # at your option. This file may not be copied, modified, or distributed # except according to those terms. -## Aristo DB -- Transaction stow/save helper +## Aristo DB -- Transaction save helper ## ========================================= ## {.push raises: [].} @@ -22,15 +22,14 @@ import # Private functions # ------------------------------------------------------------------------------ -proc txStowOk*( +proc txPersistOk*( db: AristoDbRef; # Database - persistent: bool; # Stage only unless `true` ): Result[void,AristoError] = if not db.txRef.isNil: return err(TxPendingTx) if 0 < db.stack.len: return err(TxStackGarbled) - if persistent and not db.deltaPersistentOk(): + if not db.deltaPersistentOk(): return err(TxBackendNotWritable) ok() @@ -38,14 +37,13 @@ proc txStowOk*( # Public functions # ------------------------------------------------------------------------------ -proc txStow*( +proc txPersist*( db: AristoDbRef; # Database nxtSid: uint64; # Next state ID (aka block number) - persistent: bool; # Stage only unless `true` ): Result[void,AristoError] = - ## Worker for `stow()` and `persist()` variants. + ## Worker for `persist()` variants. ## - ? db.txStowOk persistent + ? db.txPersistOk() if not db.top.isEmpty(): # Note that `deltaMerge()` will return the `db.top` argument if the @@ -57,9 +55,8 @@ proc txStow*( # New empty top layer db.top = LayerRef(vTop: db.balancer.vTop) - if persistent: - # Merge/move `balancer` into persistent tables (unless missing) - ? db.deltaPersistent nxtSid + # Merge/move `balancer` into persistent tables (unless missing) + ? db.deltaPersistent nxtSid ok() diff --git a/nimbus/db/core_db/base.nim b/nimbus/db/core_db/base.nim index bfd6496b4..bfc511cbb 100644 --- a/nimbus/db/core_db/base.nim +++ b/nimbus/db/core_db/base.nim @@ -107,7 +107,7 @@ proc persistent*( if rc.isOk or rc.error == TxPersistDelayed: # The latter clause is OK: Piggybacking on `Aristo` backend discard - elif CoreDbKvtRef(db.ctx).call(level, db.ctx.kvt) != 0: + elif CoreDbKvtRef(db.ctx).call(txFrameLevel, db.ctx.kvt) != 0: result = err(rc.error.toError($api, TxPending)) break body else: @@ -651,37 +651,30 @@ proc recast*( # Public transaction related methods # ------------------------------------------------------------------------------ -proc level*(db: CoreDbRef): int = +proc txFrameLevel*(db: CoreDbRef): int = ## Retrieve transaction level (zero if there is no pending transaction). ## db.setTrackNewApi BaseLevelFn - result = CoreDbAccRef(db.ctx).call(level, db.ctx.mpt) + result = CoreDbAccRef(db.ctx).call(txFrameLevel, db.ctx.mpt) db.ifTrackNewApi: debug logTxt, api, elapsed, result -proc newTransaction*(ctx: CoreDbCtxRef): CoreDbTxRef = +proc txFrameBegin*(ctx: CoreDbCtxRef): CoreDbTxRef = ## Constructor ## ctx.setTrackNewApi BaseNewTxFn let - kTx = CoreDbKvtRef(ctx).call(txBegin, ctx.kvt).valueOr: + kTx = CoreDbKvtRef(ctx).call(txFrameBegin, ctx.kvt).valueOr: raiseAssert $api & ": " & $error - aTx = CoreDbAccRef(ctx).call(txBegin, ctx.mpt).valueOr: + aTx = CoreDbAccRef(ctx).call(txFrameBegin, ctx.mpt).valueOr: raiseAssert $api & ": " & $error result = ctx.bless CoreDbTxRef(kTx: kTx, aTx: aTx) ctx.ifTrackNewApi: let newLevel = CoreDbAccRef(ctx).call(level, ctx.mpt) debug logTxt, api, elapsed, newLevel -proc level*(tx: CoreDbTxRef): int = - ## Print positive transaction level for argument `tx` - ## - tx.setTrackNewApi TxLevelFn - result = CoreDbAccRef(tx.ctx).call(txLevel, tx.aTx) - tx.ifTrackNewApi: debug logTxt, api, elapsed, result - proc commit*(tx: CoreDbTxRef) = tx.setTrackNewApi TxCommitFn: - let prvLevel {.used.} = CoreDbAccRef(tx.ctx).call(txLevel, tx.aTx) + let prvLevel {.used.} = CoreDbAccRef(tx.ctx).call(level, tx.aTx) CoreDbAccRef(tx.ctx).call(commit, tx.aTx).isOkOr: raiseAssert $api & ": " & $error CoreDbKvtRef(tx.ctx).call(commit, tx.kTx).isOkOr: @@ -690,7 +683,7 @@ proc commit*(tx: CoreDbTxRef) = proc rollback*(tx: CoreDbTxRef) = tx.setTrackNewApi TxRollbackFn: - let prvLevel {.used.} = CoreDbAccRef(tx.ctx).call(txLevel, tx.aTx) + let prvLevel {.used.} = CoreDbAccRef(tx.ctx).call(level, tx.aTx) CoreDbAccRef(tx.ctx).call(rollback, tx.aTx).isOkOr: raiseAssert $api & ": " & $error CoreDbKvtRef(tx.ctx).call(rollback, tx.kTx).isOkOr: @@ -699,7 +692,7 @@ proc rollback*(tx: CoreDbTxRef) = proc dispose*(tx: CoreDbTxRef) = tx.setTrackNewApi TxDisposeFn: - let prvLevel {.used.} = CoreDbAccRef(tx.ctx).call(txLevel, tx.aTx) + let prvLevel {.used.} = CoreDbAccRef(tx.ctx).call(level, tx.aTx) if CoreDbAccRef(tx.ctx).call(isTop, tx.aTx): CoreDbAccRef(tx.ctx).call(rollback, tx.aTx).isOkOr: raiseAssert $api & ": " & $error diff --git a/nimbus/db/core_db/base/api_tracking.nim b/nimbus/db/core_db/base/api_tracking.nim index ed4d0f158..c0ddaa46d 100644 --- a/nimbus/db/core_db/base/api_tracking.nim +++ b/nimbus/db/core_db/base/api_tracking.nim @@ -52,7 +52,7 @@ type BaseFinishFn = "finish" BaseLevelFn = "level" BasePushCaptureFn = "pushCapture" - BaseNewTxFn = "newTransaction" + BaseNewTxFn = "txFrameBegin" BasePersistentFn = "persistent" BaseStateBlockNumberFn = "stateBlockNumber" BaseVerifyFn = "verify" @@ -77,7 +77,7 @@ type TxCommitFn = "commit" TxDisposeFn = "dispose" - TxLevelFn = "level" + TxFrameLevelFn = "level" TxRollbackFn = "rollback" TxSaveDisposeFn = "safeDispose" diff --git a/nimbus/db/kvt/kvt_api.nim b/nimbus/db/kvt/kvt_api.nim index 328abcb77..4d6264f8a 100644 --- a/nimbus/db/kvt/kvt_api.nim +++ b/nimbus/db/kvt/kvt_api.nim @@ -52,14 +52,14 @@ type KvtApiHasKeyRcFn* = proc(db: KvtDbRef, key: openArray[byte]): Result[bool,KvtError] {.noRaise.} KvtApiIsTopFn* = proc(tx: KvtTxRef): bool {.noRaise.} - KvtApiLevelFn* = proc(db: KvtDbRef): int {.noRaise.} + KvtApiTxFrameLevelFn* = proc(db: KvtDbRef): int {.noRaise.} KvtApiPutFn* = proc(db: KvtDbRef, key, data: openArray[byte]): Result[void,KvtError] {.noRaise.} KvtApiRollbackFn* = proc(tx: KvtTxRef): Result[void,KvtError] {.noRaise.} KvtApiPersistFn* = proc(db: KvtDbRef): Result[void,KvtError] {.noRaise.} KvtApiToKvtDbRefFn* = proc(tx: KvtTxRef): KvtDbRef {.noRaise.} - KvtApiTxBeginFn* = proc(db: KvtDbRef): Result[KvtTxRef,KvtError] {.noRaise.} - KvtApiTxTopFn* = + KvtApiTxFrameBeginFn* = proc(db: KvtDbRef): Result[KvtTxRef,KvtError] {.noRaise.} + KvtApiTxFrameTopFn* = proc(db: KvtDbRef): Result[KvtTxRef,KvtError] {.noRaise.} KvtApiRef* = ref KvtApiObj @@ -73,13 +73,13 @@ type len*: KvtApiLenFn hasKeyRc*: KvtApiHasKeyRcFn isTop*: KvtApiIsTopFn - level*: KvtApiLevelFn + txFrameLevel*: KvtApiTxFrameLevelFn put*: KvtApiPutFn rollback*: KvtApiRollbackFn persist*: KvtApiPersistFn toKvtDbRef*: KvtApiToKvtDbRefFn - txBegin*: KvtApiTxBeginFn - txTop*: KvtApiTxTopFn + txFrameBegin*: KvtApiTxFrameBeginFn + txFrameTop*: KvtApiTxFrameTopFn KvtApiProfNames* = enum @@ -98,8 +98,8 @@ type KvtApiProfRollbackFn = "rollback" KvtApiProfPersistFn = "persist" KvtApiProfToKvtDbRefFn = "toKvtDbRef" - KvtApiProfTxBeginFn = "txBegin" - KvtApiProfTxTopFn = "txTop" + KvtApiProfTxFrameBeginFn = "txFrameBegin" + KvtApiProfTxFrameTopFn = "txFrameTop" KvtApiProfBeGetKvpFn = "be/getKvp" KvtApiProfBeLenKvpFn = "be/lenKvp" @@ -123,13 +123,13 @@ when AutoValidateApiHooks: doAssert not api.get.isNil doAssert not api.hasKeyRc.isNil doAssert not api.isTop.isNil - doAssert not api.level.isNil + doAssert not api.txFrameLevel.isNil doAssert not api.put.isNil doAssert not api.rollback.isNil doAssert not api.persist.isNil doAssert not api.toKvtDbRef.isNil - doAssert not api.txBegin.isNil - doAssert not api.txTop.isNil + doAssert not api.txFrameBegin.isNil + doAssert not api.txFrameTop.isNil proc validate(prf: KvtApiProfRef) = prf.KvtApiRef.validate @@ -161,13 +161,13 @@ func init*(api: var KvtApiObj) = api.len = len api.hasKeyRc = hasKeyRc api.isTop = isTop - api.level = level + api.txFrameLevel = txFrameLevel api.put = put api.rollback = rollback api.persist = persist api.toKvtDbRef = toKvtDbRef - api.txBegin = txBegin - api.txTop = txTop + api.txFrameBegin = txFrameBegin + api.txFrameTop = txFrameTop when AutoValidateApiHooks: api.validate @@ -184,16 +184,15 @@ func dup*(api: KvtApiRef): KvtApiRef = len: api.len, hasKeyRc: api.hasKeyRc, isTop: api.isTop, - level: api.level, + txFrameLevel: api.txFrameLevel, put: api.put, rollback: api.rollback, persist: api.persist, toKvtDbRef: api.toKvtDbRef, - txBegin: api.txBegin, - txTop: api.txTop) + txFrameBegin: api.txFrameBegin, + txFrameTop: api.txFrameTop) when AutoValidateApiHooks: result.validate - # ------------------------------------------------------------------------------ # Public profile API constuctor # ------------------------------------------------------------------------------ @@ -281,15 +280,15 @@ func init*( KvtApiProfToKvtDbRefFn.profileRunner: result = api.toKvtDbRef(a) - profApi.txBegin = + profApi.txFrameBegin = proc(a: KvtDbRef): auto = - KvtApiProfTxBeginFn.profileRunner: - result = api.txBegin(a) + KvtApiProfTxFrameBeginFn.profileRunner: + result = api.txFrameBegin(a) - profApi.txTop = + profApi.txFrameTop = proc(a: KvtDbRef): auto = - KvtApiProfTxTopFn.profileRunner: - result = api.txTop(a) + KvtApiProfTxFrameTopFn.profileRunner: + result = api.txFrameTop(a) let beDup = be.dup() if beDup.isNil: diff --git a/nimbus/db/kvt/kvt_desc/desc_error.nim b/nimbus/db/kvt/kvt_desc/desc_error.nim index 120b4d8ed..bfafbb115 100644 --- a/nimbus/db/kvt/kvt_desc/desc_error.nim +++ b/nimbus/db/kvt/kvt_desc/desc_error.nim @@ -33,8 +33,8 @@ type # Transaction wrappers TxArgStaleTx TxBackendNotWritable - TxLevelTooDeep - TxLevelUseless + TxFrameLevelTooDeep + TxFrameLevelUseless TxNoPendingTx TxNotTopTx TxPendingTx diff --git a/nimbus/db/kvt/kvt_init/rocks_db.nim b/nimbus/db/kvt/kvt_init/rocks_db.nim index 3ddc0ffc3..e6db3f0d7 100644 --- a/nimbus/db/kvt/kvt_init/rocks_db.nim +++ b/nimbus/db/kvt/kvt_init/rocks_db.nim @@ -185,11 +185,11 @@ proc putEndTriggeredFn(db: RdbBackendRef): PutEndFn = when extraTraceMessages: debug logTxt "putEndTriggeredFn: failed", error=hdl.error, info=hdl.info - # The error return code will signal a problem to the `txStow()` + # The error return code will signal a problem to the `txPersist()` # function which was called by `writeEvCb()` below. return err(hdl.error) - # Commit the session. This will be acknowledged by the `txStow()` + # Commit the session. This will be acknowledged by the `txPersist()` # function which was called by `writeEvCb()` below. ok() @@ -229,22 +229,22 @@ proc writeEvCb(db: RdbBackendRef): RdbWriteEventCb = # Publish session argument db.rdb.session = ws - # Execute delayed session. Note the the `txStow()` function is located + # Execute delayed session. Note the the `txPersist()` function is located # in `tx_stow.nim`. This module `tx_stow.nim` is also imported by # `kvt_tx.nim` which contains `persist() `. So the logic goes: # :: # kvt_tx.persist() --> registers a delayed write request rather - # than excuting tx_stow.txStow() + # than excuting tx_stow.txPersist() # # // the backend owner (i.e. Aristo) will start a write cycle and # // invoke the envent handler rocks_db.writeEvCb() - # rocks_db.writeEvCb() --> calls tx_stow.txStow() + # rocks_db.writeEvCb() --> calls tx_stow.txPersist() # - # tx_stow.txStow() --> calls rocks_db.putBegTriggeredFn() + # tx_stow.txPersist() --> calls rocks_db.putBegTriggeredFn() # calls rocks_db.putKvpFn() # calls rocks_db.putEndTriggeredFn() # - let rc = db.rdb.delayedPersist.txStow(persistent=true) + let rc = db.rdb.delayedPersist.txPersist() if rc.isErr: error "writeEventCb(): persist() failed", error=rc.error return false diff --git a/nimbus/db/kvt/kvt_tx.nim b/nimbus/db/kvt/kvt_tx.nim index 7460981ea..1e8abd5a5 100644 --- a/nimbus/db/kvt/kvt_tx.nim +++ b/nimbus/db/kvt/kvt_tx.nim @@ -19,26 +19,8 @@ import ./kvt_init/memory_only, ./kvt_desc -# ------------------------------------------------------------------------------ -# Public functions, getters -# ------------------------------------------------------------------------------ +export tx_frame -func txTop*(db: KvtDbRef): Result[KvtTxRef,KvtError] = - ## Getter, returns top level transaction if there is any. - db.txFrameTop() - -func isTop*(tx: KvtTxRef): bool = - ## Getter, returns `true` if the argument `tx` referes to the current top - ## level transaction. - tx.txFrameIsTop() - -func txLevel*(tx: KvtTxRef): int = - ## Getter, positive nesting level of transaction argument `tx` - tx.txFrameLevel() - -func level*(db: KvtDbRef): int = - ## Getter, non-negative nesting level (i.e. number of pending transactions) - db.txFrameLevel() # ------------------------------------------------------------------------------ # Public functions @@ -52,55 +34,6 @@ func toKvtDbRef*(tx: KvtTxRef): KvtDbRef = ## Same as `.to(KvtDbRef)` tx.db -# ------------------------------------------------------------------------------ -# Public functions: Transaction frame -# ------------------------------------------------------------------------------ - -proc txBegin*(db: KvtDbRef): Result[KvtTxRef,KvtError] = - ## Starts a new transaction. - ## - ## Example: - ## :: - ## proc doSomething(db: KvtDbRef) = - ## let tx = db.txBegin - ## defer: tx.rollback() - ## ... continue using db ... - ## tx.commit() - ## - db.txFrameBegin() - -proc rollback*( - tx: KvtTxRef; # Top transaction on database - ): Result[void,KvtError] = - ## Given a *top level* handle, this function discards all database operations - ## performed for this transactio. The previous transaction is returned if - ## there was any. - ## - tx.txFrameRollback() - -proc commit*( - tx: KvtTxRef; # Top transaction on database - ): Result[void,KvtError] = - ## Given a *top level* handle, this function accepts all database operations - ## performed through this handle and merges it to the previous layer. The - ## previous transaction is returned if there was any. - ## - tx.txFrameCommit() - -proc collapse*( - tx: KvtTxRef; # Top transaction on database - commit: bool; # Commit if `true`, otherwise roll back - ): Result[void,KvtError] = - ## Iterated application of `commit()` or `rollback()` performing the - ## something similar to - ## :: - ## while true: - ## discard tx.commit() # ditto for rollback() - ## if db.topTx.isErr: break - ## tx = db.topTx.value - ## - tx.txFrameCollapse commit - # ------------------------------------------------------------------------------ # Public functions: save database # ------------------------------------------------------------------------------ @@ -121,24 +54,11 @@ proc persist*( ## # Register for saving if piggybacked on remote database if db.backend.kind == BackendRdbTriggered: - ? db.txStowOk(persistent=true) + ? db.txPersistOk() ? db.backend.setWrReqFn db return err(TxPersistDelayed) - db.txStow(persistent=true) - -proc stow*( - db: KvtDbRef; # Database - ): Result[void,KvtError] = - ## This function is similar to `persist()` stopping short of performing the - ## final step storing on the persistent database. It fails if there is a - ## pending transaction. - ## - ## The function merges all staged data from the top layer cache onto the - ## backend stage area and leaves it there. This function can be seen as - ## a sort of a bottom level transaction `commit()`. - ## - db.txStow(persistent=false) + db.txPersist() # ------------------------------------------------------------------------------ # End diff --git a/nimbus/db/kvt/kvt_tx/tx_frame.nim b/nimbus/db/kvt/kvt_tx/tx_frame.nim index 0903e5206..62e1dc245 100644 --- a/nimbus/db/kvt/kvt_tx/tx_frame.nim +++ b/nimbus/db/kvt/kvt_tx/tx_frame.nim @@ -18,14 +18,14 @@ import results, ".."/[kvt_desc, kvt_layers] -func txFrameIsTop*(tx: KvtTxRef): bool +func isTop*(tx: KvtTxRef): bool # ------------------------------------------------------------------------------ # Private helpers # ------------------------------------------------------------------------------ func getDbDescFromTopTx(tx: KvtTxRef): Result[KvtDbRef,KvtError] = - if not tx.txFrameIsTop(): + if not tx.isTop(): return err(TxNotTopTx) let db = tx.db if tx.level != db.stack.len: @@ -49,15 +49,11 @@ func txFrameTop*(db: KvtDbRef): Result[KvtTxRef,KvtError] = else: ok(db.txRef) -func txFrameIsTop*(tx: KvtTxRef): bool = +func isTop*(tx: KvtTxRef): bool = ## Getter, returns `true` if the argument `tx` referes to the current top ## level transaction. tx.db.txRef == tx and tx.db.top.txUid == tx.txUid -func txFrameLevel*(tx: KvtTxRef): int = - ## Getter, positive nesting level of transaction argument `tx` - tx.level - func txFrameLevel*(db: KvtDbRef): int = ## Getter, non-negative nesting level (i.e. number of pending transactions) if not db.txRef.isNil: @@ -93,7 +89,7 @@ proc txFrameBegin*(db: KvtDbRef): Result[KvtTxRef,KvtError] = ok db.txRef -proc txFrameRollback*( +proc rollback*( tx: KvtTxRef; # Top transaction on database ): Result[void,KvtError] = ## Given a *top level* handle, this function discards all database operations @@ -110,7 +106,7 @@ proc txFrameRollback*( ok() -proc txFrameCommit*( +proc commit*( tx: KvtTxRef; # Top transaction on database ): Result[void,KvtError] = ## Given a *top level* handle, this function accepts all database operations @@ -135,7 +131,7 @@ proc txFrameCommit*( ok() -proc txFrameCollapse*( +proc collapse*( tx: KvtTxRef; # Top transaction on database commit: bool; # Commit if `true`, otherwise roll back ): Result[void,KvtError] = diff --git a/nimbus/db/kvt/kvt_tx/tx_stow.nim b/nimbus/db/kvt/kvt_tx/tx_stow.nim index 824bf14d5..67d89be27 100644 --- a/nimbus/db/kvt/kvt_tx/tx_stow.nim +++ b/nimbus/db/kvt/kvt_tx/tx_stow.nim @@ -8,7 +8,7 @@ # at your option. This file may not be copied, modified, or distributed # except according to those terms. -## Kvt DB -- Transaction stow/save helper +## Kvt DB -- Transaction save helper ## ====================================== ## {.push raises: [].} @@ -23,22 +23,20 @@ import # Public functions # ------------------------------------------------------------------------------ -proc txStowOk*( +proc txPersistOk*( db: KvtDbRef; # Database - persistent: bool; # Stage only unless `true` ): Result[void,KvtError] = - ## Verify that `txStow()` can go ahead + ## Verify that `txPersist()` can go ahead if not db.txRef.isNil: return err(TxPendingTx) if 0 < db.stack.len: return err(TxStackGarbled) - if persistent and not db.deltaPersistentOk(): + if not db.deltaPersistentOk(): return err(TxBackendNotWritable) ok() -proc txStow*( +proc txPersist*( db: KvtDbRef; # Database - persistent: bool; # Stage only unless `true` ): Result[void,KvtError] = ## The function saves the data from the top layer cache into the ## backend database. @@ -46,7 +44,7 @@ proc txStow*( ## If there is no backend the function returns immediately with an error. ## The same happens if there is a pending transaction. ## - ? db.txStowOk persistent + ? db.txPersistOk() if 0 < db.top.sTab.len: # Note that `deltaMerge()` will return the `db.top` argument if the @@ -58,9 +56,8 @@ proc txStow*( # New empty top layer db.top = LayerRef() - if persistent: - # Move `balancer` data into persistent tables - ? db.deltaPersistent() + # Move `balancer` data into persistent tables + ? db.deltaPersistent() ok() diff --git a/nimbus/sync/beacon/worker/db.nim b/nimbus/sync/beacon/worker/db.nim index e56defbc4..60dfff07d 100644 --- a/nimbus/sync/beacon/worker/db.nim +++ b/nimbus/sync/beacon/worker/db.nim @@ -81,7 +81,7 @@ proc dbStoreSyncStateLayout*(ctx: BeaconCtxRef; info: static[string]) = # While executing blocks there are frequent save cycles. Otherwise, an # extra save request might help to pick up an interrupted sync session. - if ctx.db.level() == 0 and ctx.stash.len == 0: + if ctx.db.txFrameLevel() == 0 and ctx.stash.len == 0: let number = ctx.db.getSavedStateBlockNumber() ctx.db.persistent(number).isOkOr: raiseAssert info & " persistent() failed: " & $$error @@ -165,9 +165,9 @@ proc dbHeadersStash*( ## .. ## let - txLevel = ctx.db.level() + txFrameLevel = ctx.db.txFrameLevel() last = first + revBlobs.len.uint64 - 1 - if 0 < txLevel: + if 0 < txFrameLevel: # Need to cache it because FCU has blocked writing through to disk. for n,data in revBlobs: ctx.stash[last - n.uint64] = data diff --git a/nimbus/transaction/call_evm.nim b/nimbus/transaction/call_evm.nim index 325dcaae5..3c9b9f6ab 100644 --- a/nimbus/transaction/call_evm.nim +++ b/nimbus/transaction/call_evm.nim @@ -38,7 +38,7 @@ proc rpcCallEvm*(args: TransactionArgs, let vmState = ? BaseVMState.new(topHeader, com) let params = ? toCallParams(vmState, args, globalGasCap, header.baseFeePerGas) - var dbTx = com.db.ctx.newTransaction() + var dbTx = com.db.ctx.txFrameBegin() defer: dbTx.dispose() # always dispose state changes ok(runComputation(params, CallResult)) @@ -50,7 +50,7 @@ proc rpcCallEvm*(args: TransactionArgs, const globalGasCap = 0 # TODO: globalGasCap should configurable by user let params = ? toCallParams(vmState, args, globalGasCap, header.baseFeePerGas) - var dbTx = com.db.ctx.newTransaction() + var dbTx = com.db.ctx.txFrameBegin() defer: dbTx.dispose() # always dispose state changes ok(runComputation(params, CallResult)) @@ -75,7 +75,7 @@ proc rpcEstimateGas*(args: TransactionArgs, hi : GasInt = GasInt args.gas.get(0.Quantity) cap: GasInt - var dbTx = com.db.ctx.newTransaction() + var dbTx = com.db.ctx.txFrameBegin() defer: dbTx.dispose() # always dispose state changes # Determine the highest gas limit can be used during the estimation. diff --git a/tests/test_aristo/test_compute.nim b/tests/test_aristo/test_compute.nim index 338e30348..239f0222b 100644 --- a/tests/test_aristo/test_compute.nim +++ b/tests/test_aristo/test_compute.nim @@ -123,7 +123,7 @@ suite "Aristo compute": check: db.mergeAccountRecord(k, v) == Result[bool, AristoError].ok(true) - check db.txStow(1, true).isOk() + check db.txPersist(1).isOk() check db.computeKeys(root).isOk() diff --git a/tests/test_aristo/test_helpers.nim b/tests/test_aristo/test_helpers.nim index c2a7e830a..7f73bb17c 100644 --- a/tests/test_aristo/test_helpers.nim +++ b/tests/test_aristo/test_helpers.nim @@ -213,10 +213,7 @@ proc schedStow*( filterMeter = if db.balancer.isNil: 0 else: db.balancer.sTab.len + db.balancer.kMap.len persistent = MaxFilterBulk < max(layersMeter, filterMeter) - if persistent: - db.persist() - else: - db.stow() + db.persist() # ------------------ diff --git a/tests/test_aristo/test_merge_proof.nim b/tests/test_aristo/test_merge_proof.nim index 399a746e1..fad104590 100644 --- a/tests/test_aristo/test_merge_proof.nim +++ b/tests/test_aristo/test_merge_proof.nim @@ -55,7 +55,7 @@ proc saveToBackend( xCheckRc rc.error == 0 block: - let rc = db.txTop() + let rc = db.txFrameTop() xCheckRc rc.error == 0 tx = rc.value @@ -72,7 +72,7 @@ proc saveToBackend( xCheckRc rc.error == 0 block: - let rc = db.txTop() + let rc = db.txFrameTop() xCheckErr rc.value.level < 0 # force error block: @@ -80,7 +80,7 @@ proc saveToBackend( xCheckRc rc.error == 0 # Update layers to original level - tx = db.txBegin().value.to(AristoDbRef).txBegin().value + tx = db.txFrameBegin().value.to(AristoDbRef).txFrameBegin().value true @@ -120,7 +120,7 @@ proc testMergeProofAndKvpList*( # ps = PartStateRef.init(db) # # Start transaction (double frame for testing) - # tx = ps.db.txBegin().value.to(AristoDbRef).txBegin().value + # tx = ps.db.txFrameBegin().value.to(AristoDbRef).txFrameBegin().value # xCheck tx.isTop() # # Update root diff --git a/tests/test_aristo/test_tx.nim b/tests/test_aristo/test_tx.nim index a4c94663c..93fe39fc9 100644 --- a/tests/test_aristo/test_tx.nim +++ b/tests/test_aristo/test_tx.nim @@ -109,7 +109,7 @@ proc randomisedLeafs( proc innerCleanUp(db: var AristoDbRef): bool {.discardable.} = ## Defer action if not db.isNil: - let rx = db.txTop() + let rx = db.txFrameTop() if rx.isOk: let rc = rx.value.collapse(commit=false) xCheckRc rc.error == 0 @@ -140,7 +140,7 @@ proc saveToBackend( xCheckRc rc.error == 0 block: - let rc = db.txTop() + let rc = db.txFrameTop() xCheckRc rc.error == 0 tx = rc.value @@ -157,7 +157,7 @@ proc saveToBackend( xCheckRc rc.error == 0 block: - let rc = db.txTop() + let rc = db.txFrameTop() xCheckErr rc.value.level < 0 # force error block: @@ -170,7 +170,7 @@ proc saveToBackend( noisy.say "***", "saveToBackend (8)", " debugID=", debugID # Update layers to original level - tx = db.txBegin().value.to(AristoDbRef).txBegin().value + tx = db.txFrameBegin().value.to(AristoDbRef).txFrameBegin().value true @@ -268,8 +268,8 @@ proc testTxMergeAndDeleteOneByOne*( # AristoDbRef.init(MemBackendRef) # # Start transaction (double frame for testing) - # xCheck db.txTop.isErr - # var tx = db.txBegin().value.to(AristoDbRef).txBegin().value + # xCheck db.txFrameTop.isErr + # var tx = db.txFrameBegin().value.to(AristoDbRef).txFrameBegin().value # xCheck tx.isTop() # xCheck tx.level == 2 @@ -375,8 +375,8 @@ proc testTxMergeAndDeleteSubTree*( # AristoDbRef.init(MemBackendRef) # # Start transaction (double frame for testing) - # xCheck db.txTop.isErr - # var tx = db.txBegin().value.to(AristoDbRef).txBegin().value + # xCheck db.txFrameTop.isErr + # var tx = db.txFrameBegin().value.to(AristoDbRef).txFrameBegin().value # xCheck tx.isTop() # xCheck tx.level == 2 diff --git a/tests/test_forked_chain.nim b/tests/test_forked_chain.nim index 997bf0d2b..dd74d3c0e 100644 --- a/tests/test_forked_chain.nim +++ b/tests/test_forked_chain.nim @@ -116,7 +116,7 @@ proc forkedChainMain*() = blk2 = cc.makeBlk(2, blk1) blk3 = cc.makeBlk(3, blk2) - dbTx = cc.db.ctx.newTransaction() + dbTx = cc.db.ctx.txFrameBegin() blk4 = cc.makeBlk(4, blk3) blk5 = cc.makeBlk(5, blk4) blk6 = cc.makeBlk(6, blk5) diff --git a/tests/test_ledger.nim b/tests/test_ledger.nim index 82302eb40..0971c4c34 100644 --- a/tests/test_ledger.nim +++ b/tests/test_ledger.nim @@ -212,7 +212,7 @@ proc runTrial3Survive(env: TestEnv, ledger: LedgerRef; inx: int; noisy = false) let eAddr = env.txs[inx].getRecipient block: - let dbTx = env.xdb.ctx.newTransaction() + let dbTx = env.xdb.ctx.txFrameBegin() block: let accTx = ledger.beginSavepoint @@ -228,7 +228,7 @@ proc runTrial3Survive(env: TestEnv, ledger: LedgerRef; inx: int; noisy = false) dbTx.rollback() block: - let dbTx = env.xdb.ctx.newTransaction() + let dbTx = env.xdb.ctx.txFrameBegin() block: let accTx = ledger.beginSavepoint @@ -247,7 +247,7 @@ proc runTrial4(env: TestEnv, ledger: LedgerRef; inx: int; rollback: bool) = let eAddr = env.txs[inx].getRecipient block: - let dbTx = env.xdb.ctx.newTransaction() + let dbTx = env.xdb.ctx.txFrameBegin() block: let accTx = ledger.beginSavepoint @@ -277,7 +277,7 @@ proc runTrial4(env: TestEnv, ledger: LedgerRef; inx: int; rollback: bool) = dbTx.commit() block: - let dbTx = env.xdb.ctx.newTransaction() + let dbTx = env.xdb.ctx.txFrameBegin() block: let accTx = ledger.beginSavepoint @@ -350,14 +350,14 @@ proc runLedgerTransactionTests(noisy = true) = test &"Run {env.txi.len} two-step trials with rollback": for n in env.txi: - let dbTx = env.xdb.ctx.newTransaction() + let dbTx = env.xdb.ctx.txFrameBegin() defer: dbTx.dispose() let ledger = env.com.getLedger() env.runTrial2ok(ledger, n) test &"Run {env.txi.len} three-step trials with rollback": for n in env.txi: - let dbTx = env.xdb.ctx.newTransaction() + let dbTx = env.xdb.ctx.txFrameBegin() defer: dbTx.dispose() let ledger = env.com.getLedger() env.runTrial3(ledger, n, rollback = true) @@ -365,21 +365,21 @@ proc runLedgerTransactionTests(noisy = true) = test &"Run {env.txi.len} three-step trials with extra db frame rollback" & " throwing Exceptions": for n in env.txi: - let dbTx = env.xdb.ctx.newTransaction() + let dbTx = env.xdb.ctx.txFrameBegin() defer: dbTx.dispose() let ledger = env.com.getLedger() env.runTrial3Survive(ledger, n, noisy) test &"Run {env.txi.len} tree-step trials without rollback": for n in env.txi: - let dbTx = env.xdb.ctx.newTransaction() + let dbTx = env.xdb.ctx.txFrameBegin() defer: dbTx.dispose() let ledger = env.com.getLedger() env.runTrial3(ledger, n, rollback = false) test &"Run {env.txi.len} four-step trials with rollback and db frames": for n in env.txi: - let dbTx = env.xdb.ctx.newTransaction() + let dbTx = env.xdb.ctx.txFrameBegin() defer: dbTx.dispose() let ledger = env.com.getLedger() env.runTrial4(ledger, n, rollback = true)